← ONYXPrint or save as PDF
Whitepaper · v1.0 · October 2026

QuantumProof

A quantum-resistant layer 1 with no elliptic-curve cryptography anywhere in the stack.

Abstract

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.

ONYXx.com/ONYXL1$ONYX
ONYX Whitepaper01 · The Threat

Every chain you hold signs with math a quantum computer breaks.

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.

NetworkSignature schemeHard problemvs. Shor
BitcoinECDSA / Schnorr · secp256k1ECDLPBroken
EthereumECDSA · secp256k1ECDLPBroken
SolanaEd25519ECDLPBroken
NEAREd25519ECDLPBroken
ONYXML-DSA-44 / ML-DSA-65Module-LWE / Module-SISNo known attack

Public keys are the attack surface

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.

Harvest now, break later

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 and hashing

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.

ONYX2 / 8
ONYX Whitepaper02 · Design Goals

Design goals and threat model

Goals

Threat model

AdversaryCapabilityMitigation
Quantum attackerRuns Shor and Grover at scaleLattice signatures (ML-DSA); 256-bit hashes
Harvesting attackerRecords all public data todayNo ECC data ever published
Replay attackerRe-broadcasts signed transactionsPer-account nonce + chain ID in signed body
Key substitutionPairs a valid sig with another keyAddress = SHA3-256(pk); node checks binding
Faulty validatorSigns an invalid or conflicting blockAttestation quorum; invalid sigs drop the block

Non-goals for testnet v1

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.

ONYX3 / 8
ONYX Whitepaper03 · Cryptography

Cryptographic primitives

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.

RoleSchemePublic keySignatureNIST category
User transactionsML-DSA-441,312 B2,420 B2
Blocks & attestationsML-DSA-651,952 B3,309 B3
Hashes, addresses, rootsSHA3-256—32 B digest~128-bit quantum
Reference: Ed25519EdDSA32 B64 Bbroken by Shor

Why ML-DSA

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.

Measured performance

Reference node: Node.js 24 with native FIPS 204 support, single core, 64-byte message.

SchemeSignVerifyKeygen
Ed25519 (reference)89 µs234 µs87 µs
ML-DSA-441,504 µs331 µs299 µs
ML-DSA-652,361 µs444 µs492 µ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.

Implementations

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.

ONYX4 / 8
ONYX Whitepaper04 · Accounts & Transactions

Accounts and transactions

Keys and addresses

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.

Transaction format

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.

Admission rules

A transaction that fails any rule is rejected at the API with the reason, before it reaches the mempool.

Size budget

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.

ONYX5 / 8
ONYX Whitepaper05 · Consensus

Quantum-safe consensus

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.

Block construction

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

Finality rule

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.

Chaining and integrity

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.

Fault behaviour

EventOutcome
Invalid proposer signatureBlock rejected; slot skipped
Fewer than 2 valid attestationsBlock rejected; transactions re-queued
Invalid transaction in mempoolNever admitted (verified at the gate)
Stale nonce at executionTransaction skipped, state untouched

Path to permissionless

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.

ONYX6 / 8
ONYX Whitepaper06 · Network & Roadmap

Testnet, interfaces and roadmap

Live testnet: onyx-testnet-1

  • Explorer: every block with its full ML-DSA-65 signatures, every transaction and account.
  • Wallet: in-browser ML-DSA-44 keys, faucet (1,000 tONYX per hour), signed transfers, seed backup.
  • Live stream: server-sent events push each new block as it is finalised.
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)

Per-block cost

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.

Roadmap

PhaseScope
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.

ONYX7 / 8
ONYX Whitepaper07 · $ONYX, Risks & References

$ONYX and disclosures

$ONYX

$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.

Migration to mainnet

$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.

Risks and disclosures

References

Move before Q-day. onyxchain.net

ONYX8 / 8