Every discussion about quantum computers and blockchains eventually arrives at the same uncomfortable place. Shor’s algorithm breaks elliptic curve cryptography. Every blockchain in production uses elliptic curve signatures. Therefore every chain will eventually have to move every user onto a new kind of key, and whoever fails to move in time loses everything.

We spent the last few months working out what that migration actually looks like for our stack — enumerating every vulnerable component, classifying what breaks and when, and benchmarking the replacement candidates on hardware a validator might realistically run. This post is what we found. The first half is the plan. The second half is the part we think is more broadly interesting: the reason one whole class of the usual migration pain does not apply to us, and what design decision it came from.

Two clocks, not one

Before any of the planning makes sense, there is a distinction that does most of the work.

Retroactive threats — harvest now, decrypt later. An adversary records encrypted traffic today and decrypts it years from now, once a sufficiently large quantum computer exists. This applies only to confidentiality. Its defining feature is that the clock is already running: every day a confidentiality surface stays classical, the pile of permanently-exposed traffic grows, and migrating later does not un-expose what was already recorded.

Real-time forgery. An adversary with a quantum computer forges signatures and proofs at the moment of protocol execution. Recording today’s signatures and proofs gives them nothing — a signature is verified on receipt, and its job is finished at that instant. This is a hard deadline, but it is a deadline rather than a race, and delay costs nothing retroactively.

There is a subtlety here that took us a while to state precisely, and it turns out to matter more than anything else in the classification. A zero-knowledge proof’s threat class is set by its role in the protocol, not by the proof system. If a proof is used to hide long-lived confidential data, the retroactive question is real — but the exposure comes from the encryption or commitment layer carrying that data, not from the proof itself, because a perfectly zero-knowledge proof hides its witness information-theoretically. Groth16 is perfectly zero-knowledge. An unbounded adversary opening one of our proofs from three years ago learns exactly nothing about its witness — not the note, not the branch, not the Merkle path. The only quantum-exposed property of every proof in our stack is soundness, which is computational. That places all of them, without exception, in the real-time-forgery class.

Combine that with the second useful observation about a public ledger — there is almost nothing on it to harvest, since block headers, transactions, balances and declarations are public by construction — and the urgent surface shrinks dramatically. Our entire retroactive exposure lives in two places: the network transport carrying traffic between nodes, and the privacy layer that hides which node proposed which block.

That is a much smaller urgent surface than most people assume when they hear “the chain is not quantum-safe.”

The plan

The migration in four phases

The migration in four phases

Phase 0 — the transport. Everything on the stack runs over the same TLS stack: consensus gossip, mempool propagation, service declarations, the privacy layer's inter-node communication. Replacing its key exchange with a post-quantum one closes the larger of our two retroactive surfaces in a single move.

This is the easiest thing in the entire programme and it should be deployed first. The mechanism is standardised, library support exists, and when we benchmarked it the result was mildly surprising. Here is one complete key exchange, everything both sides compute, measured on a Pi 5:

total compute per exchange bytes on the wire
X25519 (today) 444 µs 64 B
ML-KEM-768 99 µs 2,272 B

A post-quantum key exchange is four times cheaper in compute than the classical one it replaces. The reason is not exotic: ML-KEM’s three operations together cost less than the two Curve25519 scalar multiplications per side that they displace, and the lattice arithmetic vectorises well. (One fairness note: that comparison uses each primitive’s production library — OpenSSL for X25519, liboqs for ML-KEM. Measure both through a single uniformly-optimised library and the gap narrows to about 1.3× — narrower, but in the same direction.) We saw this at the protocol level too — a full TLS 1.3 handshake with an ML-KEM-768 group and a classical certificate ran at 869 handshakes/sec against 774 for the classical baseline. The post-quantum handshake is faster, and the inversion is not an artifact of one stack: the fastest TLS implementation we measured completed 1,934 ML-KEM-768 handshakes per second against 1,864 for its own classical baseline.

The cost is entirely on the wire, and it is per-connection rather than per-message, so it amortises to approximately zero in steady state. One packet-level detail is worth knowing: a pure ML-KEM-768 ClientHello lands at 1,370 bytes and still fits inside a single 1,400-byte segment, while every hybrid group and ML-KEM-1024 fragments it. If you care about first-flight latency, that boundary is where to look.

Because the transport is shared, this is one deployment across all node types rather than a per-team schedule. Everyone moves together or nobody does.

Phase 1 — the message layer. Our privacy layer encrypts each message separately for each hop on its path, so that a relaying node learns only what it must. That per-hop key agreement is the second retroactive surface, and unlike the transport it cannot be inherited from a standard: the ciphertext is embedded in every encapsulation layer, so replacing a 32-byte ephemeral public key with a 1,088-byte KEM ciphertext costs 3 × 1,056 = 3,168 bytes per message. Against a ~34 kB payload that is about 9%.

During transition this can be done as a hybrid, combining both shared secrets so that breaking either one is insufficient:

κ_hybrid = H(κ_ECDH ‖ κ_KEM)