EIP-8450 Post-quantum consensus key registry
No call decision · Consensus & staking · EIP status Draft · created 2026-10-15
Validators and builders pre-register hash-based signing keys that remain secure against quantum computers (leanXMSS) and a VRF root into the beacon state. The keys are kept dormant, and the actual switch to signing with them happens in a later fork.
Why it is needed
Today, every signature in Ethereum's consensus layer, attestations, block proposals, RANDAO reveals, sync committee messages, and even builder bids and envelopes, is a BLS signature. BLS relies on the hardness of the discrete logarithm problem, so once a quantum computer capable of running Shor's algorithm (a CRQC) exists, the secret key can be recovered from the public key alone. Since every validator's and builder's public key is already exposed in the beacon state, BLS must be replaced. However, creating post-quantum keys requires the validator's secret key material and new tooling, and staking pools additionally need coordination between node operators and stakeholders. If this work were all bundled into the same fork that switches the signature scheme, how many validators were actually ready would only become apparent at the moment of that fork. So this EIP splits the replacement into two steps and first introduces a fork that only registers keys. The effective balance of active validators with registered keys can be computed from the state, so the transition point can be set against an observed metric, and if a quantum computer appears to be imminent, the keys registered up to that point can serve as a recovery baseline.
What changes
Today
- Every message in the consensus layer is authenticated with a single BLS signature, and once a quantum computer exists, the secret key can be recovered from the public key in the beacon state.
- There is no way to check on-chain how many validators have prepared post-quantum keys.
- There is no way to test a post-quantum signature verifier on mainnet in advance.
After EIP-8450
- Validators upload a leanXMSS key and a VRF tree root, and builders upload a leanXMSS key, to a registry in the beacon state in advance.
- The effective balance of active validators with registered keys becomes the readiness signal used to set the transition point.
- Because every registration includes a proof of possession, clients get to run the leanXMSS verifier on mainnet ahead of time.
- Registered keys remain dormant, and every duty is still signed with BLS.
Who is affected
- Validators and node operators: The operator holding the BLS signing key registers each validator's key without any transaction from the stakeholder. Key generation and keystores need new tooling, and if a key is lost it can be replaced at intervals of 256 epochs.
- Builder: The leanXMSS key that will sign bids and envelopes is registered with the same operation. The VRF root is left at 0, and registration is only possible after becoming active.
- Client teams: Implements a leanXMSS verifier, four new containers, one block operation, and one gossip topic. The new keys are exercised on mainnet before any duty comes to depend on them.
- General users / stakers: Existing duties continue to be authenticated with BLS as before, so this fork alone changes nothing. Validators who do not register a key are also unaffected by this fork.
In depth
Validation procedure for the registration operation
The new block operation process_pq_key_registration checks the following. The index must be within the registry's range; for a validator, exit_epoch must be FAR_FUTURE_EPOCH (exit not initiated); for a builder, it must be active and vrf_root must be 0. The message's previous_change_epoch must match the change epoch stored in the state (replay protection), and if a key already exists, the current epoch must be at least the stored epoch plus MIN_PQ_KEY_CHANGE_DELAY. The BLS signature is verified in the domain computed from DOMAIN_PQ_KEY_REGISTRATION ('0x12000000') and the genesis fork version, so it remains valid across forks. The new leanXMSS key must be nonzero and not already in use by any validator or builder, and the proof of possession, signed at leaf index PQ_POSSESSION_XMSS_INDEX (0) under DOMAIN_PQ_KEY_POSSESSION ('0x13000000'), must pass verification. Anyone can submit it; only the BLS signature grants authorization. Registrations are processed after the block's other operations and after parent_execution_requests, so a registration for an entrant whose exit was initiated earlier in the same block invalidates the block.
leanXMSS and VRF tree interfaces
This EIP specifies only the interface and the properties it depends on, not a particular construction. leanXMSS is a stateful signature scheme with a 32-byte public key and a 2404-byte signature; unforgeability holds only if each leaf index is used to sign at most once. Signing the same message twice from the same leaf also counts as reuse, and any leaf index in [0, 2**32) can be used. The first 4 bytes of the signature carry the leaf index in little-endian form. The VRF tree is a hash tree whose leaves commit to secret values; once the root and index are fixed, the output is pinned to a single value absent a hash collision, and nobody can predict it before it is opened. Selection proofs normally use the hash of a unique BLS signature, but since leanXMSS signatures are not unique and can be ground, a VRF root registered before the input is known pins a single output per index. The root is not checked at registration time, so the validator client checks the tree itself before registering. The implementation lives in the Cryptography/Xmss module of the ethereum/EthLib repository at commit 6390c73ef040311e807b9047d99dca6b1be1c42f.
Changes to state and block structure
Four ProgressiveLists parallel to validators and builders are added to BeaconState. post_quantum_key_material and post_quantum_key_change_epochs are for validators, and the two with the builder_ prefix are for builders. The Validator and Builder containers themselves do not change, so light client proofs against them are unaffected before the transition. A pq_key_registrations field is added to BeaconBlockBody, capped at MAX_PQ_KEY_REGISTRATIONS (8) per block. A single registration is 2580 bytes (2404 bytes of which is the proof of possession), about 20 KiB per block, and verification costs 8 BLS checks and 8 leanXMSS checks per block. At this rate, registering 1 million validators takes 125,000 full blocks, about 17 days at 12-second slots. The state grows by 72 bytes (64 bytes of key plus 8 bytes of change epoch) per index that has ever been allocated, about 72 MB per million indices. At the fork transition, an upgrade function initializes, for every validator, an all-zero entry and FAR_FUTURE_EPOCH, and for every builder, an all-zero entry and its deposit epoch.
Re-registration limits and replay protection
A single change epoch stored per index handles both replay protection and the rate limit on changes. A registration must target the stored value via previous_change_epoch, and once applied it is updated to the current epoch, so the same registration cannot be applied twice. An entry that already has a key can only be changed after MIN_PQ_KEY_CHANGE_DELAY (256 epochs, about 27 hours at 12-second slots), which is 8 epochs in the minimal preset and must be at least 1 in every preset. A validator that has never registered is marked FAR_FUTURE_EPOCH. Changes are allowed so that a registrant who loses a seed or signer state, or who uploaded the wrong key, can recover without exiting. On the other hand, an attacker able to forge BLS signatures could replace any registrant's key, so if a quantum computer appears imminent, a fork can halt changes and treat keys registered before that point as a recovery baseline. This protects against a foreseen collapse, not against a collapse that already happened before that fork.
Builder registration and index reuse
Builders sign execution payload bids and envelopes with the BLS key in their own registry (EIP-7732), so they too need a post-quantum key. The same operation is used with an index flagged by BUILDER_INDEX_FLAG, the same way builder withdrawal does, and since no selection proof is generated, the VRF root must be 0. Because a builder index is reused after a withdrawal, FAR_FUTURE_EPOCH cannot be used to mark non-registration, so the deposit epoch takes that role instead. Registration is only possible for an active builder whose deposit epoch has finalized, so the stored epoch is guaranteed to advance each time it is applied. When an index is reassigned, add_builder_to_registry resets the entry, clearing the previous builder's key and starting over with the new deposit epoch; since MIN_BUILDER_WITHDRAWABILITY_DELAY is at least 1, any registration signed for the previous builder targets an epoch earlier than the new deposit epoch and so none of them apply. The same holds if the same BLS key re-enters at the same index.
Gossip propagation rules
The new global topic pq_key_registration carries SignedPQKeyRegistration. Before propagation, cheap checks are applied first in order: conditions that can differ by node (index exists, builder is active, stored epoch matches, key is unused) are IGNORE, while conditions that are the same in any state (exit initiated, builder's nonzero VRF root, zero leanXMSS key, BLS signature, proof of possession) are REJECT. For each (index, previous_change_epoch) pair, only the first valid registration received is let through; if that first-received registration later becomes invalid (e.g., the same key was registered earlier at a different index), the record MAY be cleared based on finalized state. While the first-received registration remains valid but not yet included, other registrations for the same pair (such as one correcting a bad key) are ignored, so a registrant who broadcast a bad key replaces it only after that registration is included and MIN_PQ_KEY_CHANGE_DELAY has passed. verify_block_body_operation_limits in the block topic gains a check that rejects blocks with more than 8 registrations.
Security limits and what readiness means
The authenticity of a registration can only be trusted as much as the BLS signature that approved it. Once a CRQC appears, an attacker could replace any registrant's key once per MIN_PQ_KEY_CHANGE_DELAY per index, so the transition must happen while BLS is still believed secure, or a fork must halt changes before that point, and a fork that switches the mandatory scheme must stop accepting BLS-approved changes. As for the strength of the primitive itself, the leanXMSS specification over Keccak-256 proves 127-bit classical strong unforgeability in the random oracle model, and the parameters target 64-bit quantum security (NIST level 1), but this target is not a proven bound. The uniqueness of VRF output relies on the assumption that there are no hash collisions, costing about 2**128 hash computations classically and about 2**85 quantumly via the Brassard-Høyer-Tapp algorithm, for 32-byte nodes. Also, a registered key only shows that it could sign once at the time of registration, so the registered balance is an upper bound on readiness, and the transition needs margin above the two-thirds finality threshold. Copying another validator's VRF root to register is not prevented, and a fork that uses the root must account for reuse of a publicly revealed opening.
Progress status
This EIP is in Draft status, created on October 15, 2026, and its specification and constants may still change. The changes apply to the consensus specification on top of Heze, and the activation fork is meant to be designated by the relevant meta EIP, not yet assigned to a specific fork. It requires EIP-7495, EIP-7732, EIP-7916, and EIP-8282 as prerequisites. leanXMSS keystores and signer state SHOULD follow EIP-8310, which extends ERC-2335. There is no record yet of a core developer call deciding on fork inclusion.