A quantum-resistant layer 1 with no elliptic-curve cryptography anywhere in the stack.
Every major blockchain authenticates value with elliptic-curve signatures that a large fault-tolerant quantum computer can break with Shor's algorithm. ONYX replaces them end to end. User transactions are signed with ML-DSA-44, blocks and validator attestations with ML-DSA-65 (NIST FIPS 204), and all hashing uses SHA3-256. Keys are generated client-side, every signature is verified before it reaches state, and the public testnet is live with an open explorer.
Public-key cryptography in today's blockchains rests on the elliptic-curve discrete logarithm problem (ECDLP). Bitcoin uses ECDSA and Schnorr over secp256k1, Ethereum uses ECDSA over secp256k1, and Solana and NEAR use Ed25519. Classical computers cannot solve ECDLP at these sizes. A quantum computer running Shor's algorithm can, in polynomial time.
| Network | Signature scheme | Hard problem | vs. Shor |
|---|---|---|---|
| Bitcoin | ECDSA / Schnorr · secp256k1 | ECDLP | Broken |
| Ethereum | ECDSA · secp256k1 | ECDLP | Broken |
| Solana | Ed25519 | ECDLP | Broken |
| NEAR | Ed25519 | ECDLP | Broken |
| ONYX | ML-DSA-44 / ML-DSA-65 | Module-LWE / Module-SIS | No known attack |
An address that has ever sent a transaction has published its public key on-chain. Given that key, Shor's algorithm recovers the private key, and with it every coin the address controls. Because ledgers are permanent and public, that exposure cannot be undone after the fact.
An adversary does not need a quantum computer today. It only needs to record exposed public keys and signed data now and break them when the hardware arrives. Migration therefore has to be complete before "Q-day", not after it.
Grover's algorithm gives a quadratic speed-up against hash pre-images, which effectively halves security bits. SHA3-256 retains roughly 128-bit security under Grover, which is why ONYX uses 256-bit hashes throughout.
The core problem: retrofitting post-quantum signatures onto an existing chain needs every holder to migrate keys, a hard fork, and new block-size economics. ONYX is designed post-quantum from genesis, so there is nothing to migrate.
| Adversary | Capability | Mitigation |
|---|---|---|
| Quantum attacker | Runs Shor and Grover at scale | Lattice signatures (ML-DSA); 256-bit hashes |
| Harvesting attacker | Records all public data today | No ECC data ever published |
| Replay attacker | Re-broadcasts signed transactions | Per-account nonce + chain ID in signed body |
| Key substitution | Pairs a valid sig with another key | Address = SHA3-256(pk); node checks binding |
| Faulty validator | Signs an invalid or conflicting block | Attestation quorum; invalid sigs drop the block |
Testnet v1 does not attempt transaction privacy, smart contracts or a permissionless validator set. These are listed on the roadmap (§7). The focus of v1 is to prove a fully post-quantum signing path from wallet to finalized block, publicly and verifiably.
ML-DSA (Module-Lattice Digital Signature Algorithm, formerly CRYSTALS-Dilithium) was standardised by NIST as FIPS 204 in August 2024. Its security reduces to the hardness of the Module Learning-With-Errors and Module Short-Integer-Solution problems over polynomial rings, for which no efficient classical or quantum algorithm is known.
| Role | Scheme | Public key | Signature | NIST category |
|---|---|---|---|---|
| User transactions | ML-DSA-44 | 1,312 B | 2,420 B | 2 |
| Blocks & attestations | ML-DSA-65 | 1,952 B | 3,309 B | 3 |
| Hashes, addresses, roots | SHA3-256 | — | 32 B digest | ~128-bit quantum |
| Reference: Ed25519 | EdDSA | 32 B | 64 B | broken by Shor |
ML-DSA is NIST's primary general-purpose signature standard. It has fast verification, uses only integer arithmetic, and is constant-time friendly. SLH-DSA (SPHINCS+, FIPS 205) rests on hashes alone but produces 7–50 KB signatures and signs slowly. Falcon (FN-DSA) has smaller signatures but needs floating-point Gaussian sampling, which is hard to implement safely. ML-DSA is the best balance for a high-throughput ledger.
Reference node: Node.js 24 with native FIPS 204 support, single core, 64-byte message.
| Scheme | Sign | Verify | Keygen |
|---|---|---|---|
| Ed25519 (reference) | 89 µs | 234 µs | 87 µs |
| ML-DSA-44 | 1,504 µs | 331 µs | 299 µs |
| ML-DSA-65 | 2,361 µs | 444 µs | 492 µs |
Verification, the operation every node performs for every transaction, costs within 2× of Ed25519. Signing is slower but happens once, on the sender's device.
Nodes use the platform's native FIPS 204 implementation. Browser wallets use the open-source @noble/post-quantum library. Both produce standard encodings, so a signature made in the browser verifies natively on the node without translation.
A wallet draws a 32-byte seed from the device's cryptographically secure RNG and derives an ML-DSA-44 keypair from it. The address is a hash of the public key:
seed ← CSPRNG(32 bytes) (pk, sk) ← ML-DSA-44.KeyGen(seed) addr = "onx1" ‖ hex( SHA3-256(pk)[0..20] )
Until an account sends its first transaction, its public key is never published. Even then it is a lattice key, which gives a quantum adversary nothing to work with.
body = canonical({ amount, chain: "onyx-testnet-1",
fee, from, nonce, to })
σ = ML-DSA-44.Sign(sk, body)
tx = body ‖ pk (1,312 B) ‖ σ (2,420 B)
hash = SHA3-256(body ‖ σ)
Canonical encoding sorts keys deterministically, so the signer and every verifier hash identical bytes. The chain field binds the signature to one network, so a testnet signature can never be replayed on another chain.
A transaction that fails any rule is rejected at the API with the reason, before it reaches the mempool.
A transfer is about 3.9 KB on the wire, roughly 15–25× an Ed25519 transfer. ONYX treats this as a design input: block limits, gossip and storage are sized for post-quantum transactions from genesis rather than retrofitted.
Testnet v1 runs a permissioned validator set of four, named Kyber, Dilithium, Falcon and Sphincs. Each holds an ML-DSA-65 keypair. Slots are 4 seconds, and the proposer rotates round-robin by height.
proposer = V[ height mod |V| ]
txRoot = SHA3-256( tx₁.hash ‖ … ‖ txₙ.hash )
header = { height, prev, time, txRoot, proposer, txCount }
H = SHA3-256( canonical(header) )
σ_p = ML-DSA-65.Sign(sk_proposer, H)
σ_i = ML-DSA-65.Sign(sk_i, H) for each other validator i
final(B) ⇔ Verify(pk_p, H, σ_p) ∧ |{ i : Verify(pk_i, H, σ_i) }| ≥ 2
The proposer plus at least two of the three attesters must produce valid ML-DSA-65 signatures over the header hash, a 3-of-4 quorum. A block that fails is discarded and its transactions return to the mempool for the next slot.
Each header commits to its parent hash and transaction root, so altering any historical transaction changes every later block hash and invalidates every signature after it. Fees in a block are credited to its proposer.
| Event | Outcome |
|---|---|
| Invalid proposer signature | Block rejected; slot skipped |
| Fewer than 2 valid attestations | Block rejected; transactions re-queued |
| Invalid transaction in mempool | Never admitted (verified at the gate) |
| Stale nonce at execution | Transaction skipped, state untouched |
The roadmap (§7) replaces the fixed set with a staked, open validator set running a BFT protocol in which every vote is an ML-DSA signature, with signature aggregation research to keep finality messages compact.
GET /api/stats GET /api/blocks?n=20 GET /api/block/:height|hash GET /api/tx/:hash GET /api/account/:onx1… POST /api/tx POST /api/faucet GET /api/live (SSE)
Each block carries four ML-DSA-65 signatures (13,236 bytes) and requires four verifications (~1.8 ms on one core). At 200 transactions per block, admission verification costs ~66 ms per slot, about 1.7% of a 4-second slot on a single core.
| Phase | Scope |
|---|---|
| 01 · Launch (now) | $ONYX launches on Solana; testnet live with ML-DSA blocks, wallet and explorer; whitepaper v1.0 |
| 02 · Scale the testnet (next) | Open validator onboarding, multi-node gossip, public RPC, stress tests, audit kickoff |
| 03 · Mainnet + migration (soon) | ONYX mainnet goes live; $ONYX holders migrate 1:1 to native ONYX via a Solana snapshot, claimed with an ML-DSA wallet |
After mainnet, research continues on PQ-native smart accounts, hash-based bridge attestations and lattice-based confidential transfers.
$ONYX is the ONYX community token, launching on Solana. Its contract address is published on the front page with a copy button. tONYX is the testnet gas asset, separate from $ONYX.
$ONYX launches on Solana so the community can form before the chain ships. When ONYX mainnet goes live, a snapshot of $ONYX balances is taken and holders claim native ONYX 1:1 by signing with their ML-DSA wallet. From that point the asset lives on a quantum-resistant ledger.
Move before Q-day. onyxchain.net