The last mile: scaling post-quantum Ethereum

The last mile: scaling post-quantum Ethereum

We began this series with the need to accelerate Ethereum's transition to stronger cryptography, in response to quantum computing and the possibility of AI-assisted mathematical breakthroughs. We then examined what a cryptographic break could damage, and how the protocol, users and operators could prepare. This final post looks at the destination: an Ethereum that can operate with post-quantum cryptography at a cost and scale people can use.

Imagine that the necessary migrations have happened and Ethereum has retired its vulnerable cryptography. Transactions are authorized with new signatures, and validators use a secure replacement for BLS. Depending on the transition, rollups might temporarily be publishing data through calldata. The network continues running, but some of its previous capacity may be expensive to recover.

That is the gap between readiness and operation at scale. Closing it requires work across execution, consensus, data availability and networking. Much of that work can advance before the transition; its order depends on which path Ethereum takes.

The goal

Completing Ethereum's transition to post-quantum cryptography would be a major milestone. The goal is to make that secure network efficient, affordable and able to scale.

For this next stage, we take the cryptographic transition as our starting point: Ethereum has adopted the new schemes and retired the vulnerable ones. Much of the remaining work concerns two closely connected problems: networking and performance. This is the distinction between pqai-ready and pqai-scaled introduced in the Ethlabs proposal we discussed previously. [1]

The networking problem starts with larger signatures. Every transaction and validator vote needs to reach the nodes that process it. If each carries a much larger signature, supporting the same activity requires more bandwidth. Increasing activity makes that burden grow further.

Signature verification is a computation that can itself be proved. A node or builder can check many signatures and generate one cryptographic proof that they are valid for the specified messages and public keys. This is signature aggregation: a shared, or aggregate, proof covers many signatures, allowing other nodes to verify that proof instead of repeating every signature check.

Across enough signatures, this can reduce both the data the network carries and the work needed to verify it. Producing the proofs introduces a performance requirement: they must be generated and combined quickly enough to keep up with transactions and validator votes.

EIP-8288 applies this approach to transactions. It would let blocks carry an aggregate proof in place of individual signatures, and let nodes combine proofs while transactions spread through the network. That addresses both the data accompanying a block and the traffic before inclusion. leanVM provides the software to generate and combine these proofs. Its performance determines how much aggregation can finish in the time available. [3] [5]

Area What a minimal transition may leave unresolved What the next stage should deliver
Execution Larger signatures and more data or verification work per transaction Aggregate proofs that reduce signature data and verification costs
Consensus Heavier voting traffic and new aggregation requirements Reliable consensus with broad participation and manageable resource costs
Data availability A possible fallback to calldata, with higher costs and lower capacity PQ blob publication suitable for rollups at scale

Some of these limitations could be resolved before Ethereum retires its old cryptography. Others might be accepted temporarily to let migration begin sooner.

The last mile

Execution: from individual signatures to an aggregate proof

Consider a wallet sending an ordinary transfer. Its signature establishes that the account authorized the action. Changing the signature scheme can protect that authorization, but it also changes what nodes must download and check.

Hash-based signatures are much larger than today's ECDSA signatures. The leanSPHINCS parameter set used in our current proposal produces a 7,740-byte signature; the exact size depends on the scheme and parameters. Carrying a separate signature for each transaction increases the bytes nodes must download and the checks they must perform. [2]

Under EIP-8288, a transaction declares the signature it requires: which key must have signed which message. The signature travels alongside it until aggregation. The block then carries the transactions, their compact signature requirements and an aggregate proof satisfying those requirements. Execution clients verify that proof in place of the original signatures. This is how the proposal reduces the data and verification burden described above. [3]

Recursive aggregation combines work already done: a new proof can establish that several earlier proofs are valid and also cover new signatures. Nodes processing pending transactions and builders assembling blocks can contribute proofs that are eventually combined into the block's aggregate proof. [4]

For signature aggregation, the proof establishes that the signatures are valid for the specified public keys and messages. Nodes still need to execute the transactions and check the other rules, including account balances and nonces. A valid signature alone does not make a transaction valid. [3]

Aggregators use leanVM to run programs that verify signatures or earlier proofs, and generate a proof that those programs completed successfully. Other nodes run the corresponding proof verifier. Making proof generation faster lets aggregators process more signatures and combine more proofs within the time available. Its development covers both leanSPHINCS user signatures and leanXMSS validator signatures. Implementation and formal verification work are ongoing. [5]

This is why we want Hegota to introduce native PQ signatures with a design that can grow into EIP-8288. Our minimal leanSPHINCS proposal establishes that foundation: transactions declare their signature requirements, and signatures initially travel alongside them for direct verification. A later upgrade could replace those individual signatures with an aggregate proof while preserving the transaction format, account logic and keys. The aim is to make PQ accounts available sooner and let them benefit from aggregation as that infrastructure becomes ready. [2]

Several design details remain open, but we believe aggregation can be introduced in stages. Starting with builders could keep the initial protocol upgrade focused on supporting aggregate proofs in blocks, while giving the mempool implementation more time to develop.

Once that foundation is in place, leanMempool could be rolled out through client and networking updates as its implementation becomes ready. Provided it uses the same proof format and block-validation rules, this second step would not require another hard fork. [3]

A first step: aggregation by builders

In this first stage, transactions and their individual signatures would travel through the network as usual. Builders, which assemble execution payloads, would generate a proof covering the signatures of the transactions they select. The protocol would require that proof for the block to be valid.

The immediate benefit is at block publication and validation. With enough signatures aggregated, nodes download less data for signature verification and check one proof instead of verifying every signature separately. Execution clients would need a recursive verifier, the software that checks this proof against the block's declared requirements. Nodes could verify it without generating proofs themselves. [3]

The work before inclusion would remain largely unchanged: individual signatures still have to reach builders through the mempool, and builders still do the aggregation. This provides a way to introduce aggregate proofs into block validation before deploying aggregation throughout the mempool. Its feasibility depends on workload, proving performance and network design. [11]

The next step: leanMempool

leanMempool extends aggregation to the period before block construction. Participating nodes work with their local mempools, the collections of transactions waiting for inclusion. They aggregate signatures and proofs, then send the transactions and an aggregate proof to peers. Builders receive work already done across the network and combine or adjust it to cover the transactions selected for their block. [4]

The additional benefit is that peers can receive one proof covering many signatures instead of receiving each signature, and more of the proving work happens before it reaches the builder. The bandwidth impact depends on proof size, batch size, proving speed and how peers exchange proofs.

What each stage changes

ApproachBefore block inclusionBlock publication and validation
No signature aggregationTransactions travel with individual signatures. Nodes check those signatures when accepting transactions.The block carries the individual signatures. Each execution client verifies them separately.
Builders aggregateIndividual signatures still travel to builders, which generate the aggregate proof.One aggregate proof replaces the individual signatures. Each execution client verifies the proof against the transactions' requirements.
Builders + leanMempoolParticipating nodes aggregate as transactions spread. Peers can exchange proofs covering many signatures, and builders complete the aggregate for their selected transactions.The block still carries one aggregate proof, verified in the same way. The additional improvement is in how signatures and proving work reach the builder.

These approaches handle the same PQ transactions. Aggregation targets their signature data and verification costs; the transaction contents still need to reach nodes, and normal EVM execution still takes place. The savings depend on how much work each proof covers and the cost of producing and distributing it. [11]

The diagram follows the two aggregation paths through the wallet, builder, execution client (EL) and consensus client (CL).

End-to-end transaction flow
From the wallet, through EL and CL, and back

Start with the actors, then reveal each step with Play or Next step. Earlier steps stay visible. Compare the two aggregation approaches across all three stages.

EL = execution client · CL = consensus client. The EL and CL peer networks are shown separately. Each network cluster stands for many peers; propagation can take multiple hops. RPC and Engine API arrows show specific client connections.

Stage 1 / 3

Broadcast to multiple peersOne delivery or local interface
Builders aggregate
Who generates proofsPrimarily builders
What reaches the builderIndividual signatures reach the builder
1. Submit, propagate and build

Public transactions spread through execution peers. This example shows a builder using its own EL to receive them and supply its local transaction pool.

Participants
  • WalletSigns the transaction
  • ELRPC + local mempool
  • EL peersP2P network
  • ELBuilder’s intake
  • BuilderPayload construction
  1. Wallet → entry ELSubmit the signed transactionThe wallet submits a transaction and its individual post-quantum signature to an execution client through an RPC endpoint.
  2. Entry ELCheck the transaction for the local mempoolThe entry EL checks the signature and its admission rules before accepting the transaction into its local pool.
  3. Entry EL → execution peersPropagate through the EL peer networkP2P broadcast · multiple peersThe EL shares the transaction with peers, which can forward it to more peers. Announcements, requests and transaction delivery depend on the networking protocol. The branches represent repeated peer-to-peer propagation.
  4. Execution peers → builder-side ELReach the builder’s network intakeThe builder-side EL receives the transaction through its own peer connections. The wallet’s entry EL need not have a direct connection to the builder.
  5. Builder-side ELCheck the received transactionThis EL applies its own signature and mempool checks. Each execution client maintains its own pool of pending transactions.
  6. Builder-side EL → building logicMake pending transactions available to the builderIn this example, the building logic reads transactions accepted by its execution client. This local integration depends on the builder implementation; builders can also integrate their own network intake.
  7. BuilderConstruct the execution payloadThe builder selects and executes transactions to construct an execution payload.
  8. BuilderProduce the aggregate proofThe builder generates a proof covering the signature requirements of its selected transactions. The payload and proof are ready for the proposal and publication path.
2. Gossip the bid, beacon block and execution payload

This illustrates ePBS public gossip. Proposer preferences have already been announced. The network cluster represents many CL peers and repeated forwarding between them.

Participants
  • BuilderBid + payload publisher
  • CL peersP2P gossip network
  • CLProposer side
  • CLReceiving node
  1. Builder → consensus peersGossip the execution-payload bidP2P broadcast · multiple peersThe builder broadcasts a signed execution-payload bid on the consensus gossip network. The bid commits to the payload it will publish if selected. This diagram follows the public ePBS bid path.
  2. Consensus peers → proposer CLReceive candidate bids from peersThe proposer learns of candidate bids through its CL’s peer connections. Bid delivery and selection can also use other mechanisms; this sequence illustrates public gossip.
  3. Proposer CL + validatorPrepare the consensus proposalThe proposing validator selects a bid. Its consensus and validator software prepare and sign a beacon block containing the selected builder commitment.
  4. Proposer CL → consensus peersGossip the beacon blockP2P broadcast · multiple peersThe proposer’s CL publishes the signed beacon block to peers, which propagate it across the consensus network.
  5. Consensus peers → builder and receiving CLDeliver the block through the peer networkThe selected builder learns that its bid was included. Receiving CLs obtain the same beacon block through gossip. The diagram highlights two recipients among many peers.
  6. Receiving CLValidate the consensus blockThe receiving CL checks the proposer signature and consensus rules. Execution validation follows through the paired EL.
  7. Selected builder → consensus peersGossip the committed execution payloadP2P broadcast · multiple peersAfter the block selecting its bid is published, the builder broadcasts its signed execution-payload envelope. In this proposed PQ path, the payload carries transactions and their aggregate signature proof.
  8. Consensus peers → receiving CLReceive the payload through gossipPeers propagate the execution-payload envelope separately from the beacon block. The highlighted receiving CL is one of many recipients.
  9. Receiving CLMatch the payload to the commitmentThe receiving CL checks the signed envelope and its relationship to the selected commitment, then passes execution validation to its paired EL. Availability and timeliness duties also apply.
3. Validate, update the chain view and report inclusion

The receiving CL hands the payload to its paired EL over the Engine API. The remaining sequence follows a valid payload selected into the canonical chain.

Participants
  • CLReceiving node
  • ELSame receiving node
  • WalletUses an EL RPC
  1. Receiving CL → its paired ELRequest execution validation through the Engine APIThe CL sends the execution payload to its paired EL through the local Engine API connection. This is a call between paired clients. Method versions and the proposed PQ payload extension are omitted here.
  2. ELRun the recursive verifierThe execution client derives the signature requirements from the transactions and verifies the aggregate proof against those requirements.
  3. ELPerform normal execution validationThe EL executes the transactions and checks their other validity rules and the resulting state. The signature proof does not replace these checks.
  4. EL → CLReturn the execution resultThe EL reports VALID, INVALID or a pending result such as SYNCING or ACCEPTED. The remaining steps here follow VALID; the alternatives are explained below.
  5. CLCombine execution validity with consensusThe CL uses execution validity together with consensus rules and validator votes to determine its chain view. VALID alone does not make a payload the head or finalize it.
  6. CL → ELTell the EL which chain to followThrough the Engine API, the CL communicates the selected head and the safe and finalized block references as consensus advances. Consensus duties can proceed on their own schedule.
  7. ELApply the consensus client’s chain choiceThe EL updates its canonical execution-chain view to follow the CL’s selected head. Later fork-choice updates can change the head or advance finality.
  8. Wallet → EL RPCQuery the transaction’s inclusionThe wallet asks an execution client or an RPC service backed by one for the transaction receipt.
  9. EL RPC → walletReport inclusion to the userThe receipt identifies the transaction’s inclusion and execution result. Inclusion is not finality: the wallet must also track confirmations or the finalized chain, according to its needs.
leanMempool
Who generates proofsEL aggregation participants and builders
What reaches the builderProofs, plus any remaining raw signatures
1. Submit, aggregate across peers and build

Participating EL peers prove and combine signature checks during propagation. The builder receives transaction bodies and accumulated proofs through its network intake.

Participants
  • WalletSigns the transaction
  • ELRPC + local mempool
  • EL peersP2P network
  • ELBuilder’s intake
  • BuilderPayload construction
  1. Wallet → entry ELSubmit the signed transactionThe wallet submits a transaction and its individual post-quantum signature to an execution-network participant.
  2. Entry EL + aggregation softwareProve signature checks before block constructionThis participant checks transactions for its mempool and generates a proof covering their signature requirements. Aggregation-capable participants take on this proving work.
  3. Entry EL → execution peersPropagate transactions and proofs across peersP2P broadcast · multiple peersTransaction bodies and covering proofs spread through the peer network. Peers can request missing data; bodies and proofs need not travel together in one message. The branches illustrate propagation to several peers.
  4. Aggregation participants across the EL networkCombine proofs as transactions propagateAggregation-capable participants combine received proofs and additional signatures into proofs covering larger sets of requirements, then share the results with peers. Several participants can do this independently.
  5. Execution peers → builder-side ELReach the builder’s network intakeThrough its peer connections, the builder-side EL receives transaction bodies, covering proofs and any remaining individual signatures. This is one way to integrate a builder with leanMempool.
  6. Builder-side ELCheck the received transactions and proofsThe receiving software checks proofs against the declared requirements and applies its mempool rules. It may need to fetch missing bodies or proof data before admitting a transaction.
  7. Builder-side EL → building logicSupply transactions and accumulated proving workThe local integration gives the builder access to transaction bodies and proofs produced by network participants. The exact API and process layout depend on the builder implementation.
  8. BuilderComplete the execution payloadThe builder selects and executes transactions, then combines or adjusts proofs and processes remaining signatures so the final proof covers its selected requirements.
2. Gossip the bid, beacon block and execution payload

This illustrates ePBS public gossip. Proposer preferences have already been announced. The network cluster represents many CL peers and repeated forwarding between them.

Participants
  • BuilderBid + payload publisher
  • CL peersP2P gossip network
  • CLProposer side
  • CLReceiving node
  1. Builder → consensus peersGossip the execution-payload bidP2P broadcast · multiple peersThe builder broadcasts a signed execution-payload bid on the consensus gossip network. The bid commits to the payload it will publish if selected. This diagram follows the public ePBS bid path.
  2. Consensus peers → proposer CLReceive candidate bids from peersThe proposer learns of candidate bids through its CL’s peer connections. Bid delivery and selection can also use other mechanisms; this sequence illustrates public gossip.
  3. Proposer CL + validatorPrepare the consensus proposalThe proposing validator selects a bid. Its consensus and validator software prepare and sign a beacon block containing the selected builder commitment.
  4. Proposer CL → consensus peersGossip the beacon blockP2P broadcast · multiple peersThe proposer’s CL publishes the signed beacon block to peers, which propagate it across the consensus network.
  5. Consensus peers → builder and receiving CLDeliver the block through the peer networkThe selected builder learns that its bid was included. Receiving CLs obtain the same beacon block through gossip. The diagram highlights two recipients among many peers.
  6. Receiving CLValidate the consensus blockThe receiving CL checks the proposer signature and consensus rules. Execution validation follows through the paired EL.
  7. Selected builder → consensus peersGossip the committed execution payloadP2P broadcast · multiple peersAfter the block selecting its bid is published, the builder broadcasts its signed execution-payload envelope. In this proposed PQ path, the payload carries transactions and their aggregate signature proof.
  8. Consensus peers → receiving CLReceive the payload through gossipPeers propagate the execution-payload envelope separately from the beacon block. The highlighted receiving CL is one of many recipients.
  9. Receiving CLMatch the payload to the commitmentThe receiving CL checks the signed envelope and its relationship to the selected commitment, then passes execution validation to its paired EL. Availability and timeliness duties also apply.
3. Validate, update the chain view and report inclusion

The receiving CL hands the payload to its paired EL over the Engine API. The remaining sequence follows a valid payload selected into the canonical chain.

Participants
  • CLReceiving node
  • ELSame receiving node
  • WalletUses an EL RPC
  1. Receiving CL → its paired ELRequest execution validation through the Engine APIThe CL sends the execution payload to its paired EL through the local Engine API connection. This is a call between paired clients. Method versions and the proposed PQ payload extension are omitted here.
  2. ELRun the recursive verifierThe execution client derives the signature requirements from the transactions and verifies the aggregate proof against those requirements.
  3. ELPerform normal execution validationThe EL executes the transactions and checks their other validity rules and the resulting state. The signature proof does not replace these checks.
  4. EL → CLReturn the execution resultThe EL reports VALID, INVALID or a pending result such as SYNCING or ACCEPTED. The remaining steps here follow VALID; the alternatives are explained below.
  5. CLCombine execution validity with consensusThe CL uses execution validity together with consensus rules and validator votes to determine its chain view. VALID alone does not make a payload the head or finalize it.
  6. CL → ELTell the EL which chain to followThrough the Engine API, the CL communicates the selected head and the safe and finalized block references as consensus advances. Consensus duties can proceed on their own schedule.
  7. ELApply the consensus client’s chain choiceThe EL updates its canonical execution-chain view to follow the CL’s selected head. Later fork-choice updates can change the head or advance finality.
  8. Wallet → EL RPCQuery the transaction’s inclusionThe wallet asks an execution client or an RPC service backed by one for the transaction receipt.
  9. EL RPC → walletReport inclusion to the userThe receipt identifies the transaction’s inclusion and execution result. Inclusion is not finality: the wallet must also track confirmations or the finalized chain, according to its needs.
If the EL does not return VALID

INVALID: the CL must account for the invalid execution payload in fork choice; the valid-payload continuation shown above does not apply.

SYNCING or ACCEPTED: validation is pending. These statuses do not establish execution validity.

Inclusion is not finality. Consensus votes and later chain updates establish finality. A receipt alone does not.

Builders aggregate. A wallet submits a signed transaction to an EL. Execution peers propagate it to the builder’s intake. The builder selects transactions and produces their aggregate signature proof. Its bid, the selected beacon block and the execution payload then propagate through consensus gossip. The receiving CL asks its EL to verify the proof and execute the transactions; later chain updates establish inclusion and finality.

Builders + leanMempool. Participating execution peers generate and combine signature proofs while transactions propagate. The builder receives that accumulated proving work and completes the proof for its chosen transactions. Payload publication, CL–EL validation and the wallet’s receipt follow the same path as in the builder-only approach.

Read the complete flow as text

Each step names the participants, the action and what the message or proof means. These views group responsibilities; network activity and validation can overlap.

Builders aggregate
1. Submit, propagate and build

Public transactions spread through execution peers. This example shows a builder using its own EL to receive them and supply its local transaction pool.

  1. Submit the signed transactionWallet → entry EL

    The wallet submits a transaction and its individual post-quantum signature to an execution client through an RPC endpoint.

  2. Check the transaction for the local mempoolEntry EL

    The entry EL checks the signature and its admission rules before accepting the transaction into its local pool.

  3. Propagate through the EL peer networkEntry EL → execution peers

    The EL shares the transaction with peers, which can forward it to more peers. Announcements, requests and transaction delivery depend on the networking protocol. The branches represent repeated peer-to-peer propagation.

  4. Reach the builder’s network intakeExecution peers → builder-side EL

    The builder-side EL receives the transaction through its own peer connections. The wallet’s entry EL need not have a direct connection to the builder.

  5. Check the received transactionBuilder-side EL

    This EL applies its own signature and mempool checks. Each execution client maintains its own pool of pending transactions.

  6. Make pending transactions available to the builderBuilder-side EL → building logic

    In this example, the building logic reads transactions accepted by its execution client. This local integration depends on the builder implementation; builders can also integrate their own network intake.

  7. Construct the execution payloadBuilder

    The builder selects and executes transactions to construct an execution payload.

  8. Produce the aggregate proofBuilder

    The builder generates a proof covering the signature requirements of its selected transactions. The payload and proof are ready for the proposal and publication path.

2. Gossip the bid, beacon block and execution payload

This illustrates ePBS public gossip. Proposer preferences have already been announced. The network cluster represents many CL peers and repeated forwarding between them.

  1. Gossip the execution-payload bidBuilder → consensus peers

    The builder broadcasts a signed execution-payload bid on the consensus gossip network. The bid commits to the payload it will publish if selected. This diagram follows the public ePBS bid path.

  2. Receive candidate bids from peersConsensus peers → proposer CL

    The proposer learns of candidate bids through its CL’s peer connections. Bid delivery and selection can also use other mechanisms; this sequence illustrates public gossip.

  3. Prepare the consensus proposalProposer CL + validator

    The proposing validator selects a bid. Its consensus and validator software prepare and sign a beacon block containing the selected builder commitment.

  4. Gossip the beacon blockProposer CL → consensus peers

    The proposer’s CL publishes the signed beacon block to peers, which propagate it across the consensus network.

  5. Deliver the block through the peer networkConsensus peers → builder and receiving CL

    The selected builder learns that its bid was included. Receiving CLs obtain the same beacon block through gossip. The diagram highlights two recipients among many peers.

  6. Validate the consensus blockReceiving CL

    The receiving CL checks the proposer signature and consensus rules. Execution validation follows through the paired EL.

  7. Gossip the committed execution payloadSelected builder → consensus peers

    After the block selecting its bid is published, the builder broadcasts its signed execution-payload envelope. In this proposed PQ path, the payload carries transactions and their aggregate signature proof.

  8. Receive the payload through gossipConsensus peers → receiving CL

    Peers propagate the execution-payload envelope separately from the beacon block. The highlighted receiving CL is one of many recipients.

  9. Match the payload to the commitmentReceiving CL

    The receiving CL checks the signed envelope and its relationship to the selected commitment, then passes execution validation to its paired EL. Availability and timeliness duties also apply.

3. Validate, update the chain view and report inclusion

The receiving CL hands the payload to its paired EL over the Engine API. The remaining sequence follows a valid payload selected into the canonical chain.

  1. Request execution validation through the Engine APIReceiving CL → its paired EL

    The CL sends the execution payload to its paired EL through the local Engine API connection. This is a call between paired clients. Method versions and the proposed PQ payload extension are omitted here.

  2. Run the recursive verifierEL

    The execution client derives the signature requirements from the transactions and verifies the aggregate proof against those requirements.

  3. Perform normal execution validationEL

    The EL executes the transactions and checks their other validity rules and the resulting state. The signature proof does not replace these checks.

  4. Return the execution resultEL → CL

    The EL reports VALID, INVALID or a pending result such as SYNCING or ACCEPTED. The remaining steps here follow VALID; the alternatives are explained below.

  5. Combine execution validity with consensusCL

    The CL uses execution validity together with consensus rules and validator votes to determine its chain view. VALID alone does not make a payload the head or finalize it.

  6. Tell the EL which chain to followCL → EL

    Through the Engine API, the CL communicates the selected head and the safe and finalized block references as consensus advances. Consensus duties can proceed on their own schedule.

  7. Apply the consensus client’s chain choiceEL

    The EL updates its canonical execution-chain view to follow the CL’s selected head. Later fork-choice updates can change the head or advance finality.

  8. Query the transaction’s inclusionWallet → EL RPC

    The wallet asks an execution client or an RPC service backed by one for the transaction receipt.

  9. Report inclusion to the userEL RPC → wallet

    The receipt identifies the transaction’s inclusion and execution result. Inclusion is not finality: the wallet must also track confirmations or the finalized chain, according to its needs.

leanMempool
1. Submit, aggregate across peers and build

Participating EL peers prove and combine signature checks during propagation. The builder receives transaction bodies and accumulated proofs through its network intake.

  1. Submit the signed transactionWallet → entry EL

    The wallet submits a transaction and its individual post-quantum signature to an execution-network participant.

  2. Prove signature checks before block constructionEntry EL + aggregation software

    This participant checks transactions for its mempool and generates a proof covering their signature requirements. Aggregation-capable participants take on this proving work.

  3. Propagate transactions and proofs across peersEntry EL → execution peers

    Transaction bodies and covering proofs spread through the peer network. Peers can request missing data; bodies and proofs need not travel together in one message. The branches illustrate propagation to several peers.

  4. Combine proofs as transactions propagateAggregation participants across the EL network

    Aggregation-capable participants combine received proofs and additional signatures into proofs covering larger sets of requirements, then share the results with peers. Several participants can do this independently.

  5. Reach the builder’s network intakeExecution peers → builder-side EL

    Through its peer connections, the builder-side EL receives transaction bodies, covering proofs and any remaining individual signatures. This is one way to integrate a builder with leanMempool.

  6. Check the received transactions and proofsBuilder-side EL

    The receiving software checks proofs against the declared requirements and applies its mempool rules. It may need to fetch missing bodies or proof data before admitting a transaction.

  7. Supply transactions and accumulated proving workBuilder-side EL → building logic

    The local integration gives the builder access to transaction bodies and proofs produced by network participants. The exact API and process layout depend on the builder implementation.

  8. Complete the execution payloadBuilder

    The builder selects and executes transactions, then combines or adjusts proofs and processes remaining signatures so the final proof covers its selected requirements.

2. Gossip the bid, beacon block and execution payload

This illustrates ePBS public gossip. Proposer preferences have already been announced. The network cluster represents many CL peers and repeated forwarding between them.

  1. Gossip the execution-payload bidBuilder → consensus peers

    The builder broadcasts a signed execution-payload bid on the consensus gossip network. The bid commits to the payload it will publish if selected. This diagram follows the public ePBS bid path.

  2. Receive candidate bids from peersConsensus peers → proposer CL

    The proposer learns of candidate bids through its CL’s peer connections. Bid delivery and selection can also use other mechanisms; this sequence illustrates public gossip.

  3. Prepare the consensus proposalProposer CL + validator

    The proposing validator selects a bid. Its consensus and validator software prepare and sign a beacon block containing the selected builder commitment.

  4. Gossip the beacon blockProposer CL → consensus peers

    The proposer’s CL publishes the signed beacon block to peers, which propagate it across the consensus network.

  5. Deliver the block through the peer networkConsensus peers → builder and receiving CL

    The selected builder learns that its bid was included. Receiving CLs obtain the same beacon block through gossip. The diagram highlights two recipients among many peers.

  6. Validate the consensus blockReceiving CL

    The receiving CL checks the proposer signature and consensus rules. Execution validation follows through the paired EL.

  7. Gossip the committed execution payloadSelected builder → consensus peers

    After the block selecting its bid is published, the builder broadcasts its signed execution-payload envelope. In this proposed PQ path, the payload carries transactions and their aggregate signature proof.

  8. Receive the payload through gossipConsensus peers → receiving CL

    Peers propagate the execution-payload envelope separately from the beacon block. The highlighted receiving CL is one of many recipients.

  9. Match the payload to the commitmentReceiving CL

    The receiving CL checks the signed envelope and its relationship to the selected commitment, then passes execution validation to its paired EL. Availability and timeliness duties also apply.

3. Validate, update the chain view and report inclusion

The receiving CL hands the payload to its paired EL over the Engine API. The remaining sequence follows a valid payload selected into the canonical chain.

  1. Request execution validation through the Engine APIReceiving CL → its paired EL

    The CL sends the execution payload to its paired EL through the local Engine API connection. This is a call between paired clients. Method versions and the proposed PQ payload extension are omitted here.

  2. Run the recursive verifierEL

    The execution client derives the signature requirements from the transactions and verifies the aggregate proof against those requirements.

  3. Perform normal execution validationEL

    The EL executes the transactions and checks their other validity rules and the resulting state. The signature proof does not replace these checks.

  4. Return the execution resultEL → CL

    The EL reports VALID, INVALID or a pending result such as SYNCING or ACCEPTED. The remaining steps here follow VALID; the alternatives are explained below.

  5. Combine execution validity with consensusCL

    The CL uses execution validity together with consensus rules and validator votes to determine its chain view. VALID alone does not make a payload the head or finalize it.

  6. Tell the EL which chain to followCL → EL

    Through the Engine API, the CL communicates the selected head and the safe and finalized block references as consensus advances. Consensus duties can proceed on their own schedule.

  7. Apply the consensus client’s chain choiceEL

    The EL updates its canonical execution-chain view to follow the CL’s selected head. Later fork-choice updates can change the head or advance finality.

  8. Query the transaction’s inclusionWallet → EL RPC

    The wallet asks an execution client or an RPC service backed by one for the transaction receipt.

  9. Report inclusion to the userEL RPC → wallet

    The receipt identifies the transaction’s inclusion and execution result. Inclusion is not finality: the wallet must also track confirmations or the finalized chain, according to its needs.

This follows public transaction propagation and the ePBS gossip path. The builder-side EL illustrates one integration; builders can use their own intake architecture. Proposer preferences are assumed to be available before bidding. Data-availability sidecars and individual consensus votes are outside this transaction path. Sources: EIP-8288, aggregation networking, the Gloas gossip specification and the Engine API. The proposed PQ proof carriage is illustrative. The panels show dependencies and responsibilities; network activity and validation can overlap.

Beyond signatures

Applications need to prove more than ownership of a key. A private payment, for example, may need to establish that a user can spend funds without revealing which funds are theirs. Supporting these checks efficiently matters for wallets, privacy applications and rollups.

A large part of verifying a STARK involves checking polynomial commitments. These bind the prover to mathematical data and let a verifier check claims about its values. leanPCS would allow those checks to be covered by aggregation, while each application's contract performs the remaining verification steps in the EVM.

Two applications could therefore use different proof systems, provided they use the supported commitment scheme. Each would keep its own contract logic, but the expensive polynomial checks from both could be covered by the block's aggregate proof. Those checks would no longer have to run separately inside each application's contract. [6]

In his recent explanation, Vitalik Buterin argues that this could provide a route to general proof support before Ethereum standardizes the broader leanSTARK programming interface. For developers, the attraction is flexibility across proof systems. leanPCS remains under discussion as an extension to the published EIP-8288 draft, which currently describes leanSTARK. [6]

Consensus: the route depends on how Ethereum gets ready

Consensus has its own version of the size problem. Validators produce many votes, and Ethereum must collect and verify them within the time available. Hash-based signatures such as leanXMSS require different aggregation machinery from BLS. The cost of that machinery helps determine how many participants the network can support and how quickly it can reach agreement. [5]

Two routes are being considered. PQ Gasper would adapt today's consensus design to post-quantum cryptography. PQ Decoupled Consensus would combine the cryptographic transition with a change in how validators vote. Which offers the better path to readiness remains an open question. [1]

Validators help answer two questions: which block should the chain build on next, and which part of its history has enough agreement to be considered final? Gasper combines votes serving both purposes. Decoupled Consensus separates them: a smaller committee votes on the chain's head, while the wider validator set votes on finality. Each duty can then have its own schedule for sending, collecting and aggregating votes. The experimental pq and pq-dc branches both use leanXMSS and STARK signature proofs. The latter already sketches their integration with separate voting duties, with some aggregation details still unfinished. [7]

Consensus · two possible PQ routes
From votes to head choice and finality

Compare PQ Gasper with PQ Decoupled Consensus using the pq and pq-dc drafts. Choose a view: it starts with the actors, then each step adds its arrows, actions and text. Earlier steps stay visible.

CL = consensus client · EL = execution client. Validators sign with leanXMSS. Aggregators prove signature checks; the proposer merges the proofs for its block. Receiving CLs verify them and process the votes.

Head selection and finality recur throughout the life of the chain. The views separate their responsibilities for explanation.

Branched arrows show gossip reaching several peers, with one recipient highlighted for the following steps. Validators publish through their CLs. Straight CL–EL arrows are local Engine API calls. The head-vote and finality views can overlap in time.

Broadcast to multiple peersOne delivery or local interface
PQ Gasper
Voting structureHead + checkpoint vote in one attestation
Finality clockEpoch-based Casper FFG
Head: LMD-GHOSTFinality: Casper FFGSignature: covers both
Block checks: CL duties and the separate payload path

The beacon block and execution payload have separate publication and validation paths. This view groups responsibilities; voting follows the protocol’s timing and payload-status rules.

Participants
  • CLProposer side
  • CLValidator’s node
  • ELPaired client
  • ValidatorSigning software
  1. Proposer CL → consensus peersGossip the beacon block to receiving peersP2P broadcast · multiple peersThe proposer’s CL gossips the signed beacon block, including selected consensus votes and their merged STARK proof. Peers forward it; the diagram follows one receiving CL. The execution payload is published separately.
  2. CLValidate the consensus blockThe CL checks the proposer’s XMSS signature, the included votes and their merged proof, together with the other consensus-state rules.
  3. CL → validatorPrepare a vote under the applicable rulesThe validator’s signing software receives a duty and eligible vote data from its CL. Voting uses the local consensus view and the protocol’s timing rules.
  4. CL → ELRequest execution validation on the payload pathWhen the separate payload is available and its envelope and data-availability checks pass, the CL asks its EL to validate execution.
  5. EL → CLReturn the execution resultThe EL executes and validates the payload. The CL tracks execution validity separately from receipt of the beacon block.
  6. CLMaintain the consensus view as information arrivesThe CL combines block, payload and voting information under the chosen consensus rules. The execution figure above expands the payload path.
Coupled votes: one attestation serves head and finality

Validators sign with leanXMSS. Each beacon committee has assigned aggregators with staggered collection and broadcast times in the pq draft.

Participants
  • ValidatorsSigners + their CLs
  • AggregatorsAssigned CL peers
  • CLOne receiving peer
  • ELPaired client
  1. ValidatorsSign one combined attestation with leanXMSSThe vote contains a head block and source and target checkpoints. A validator uses the XMSS leaf assigned to the target epoch.
  2. Validators’ CLs → attestation subnetPublish the individual attestationP2P broadcast · multiple peersAfter signing, the validator’s CL gossips the SingleAttestation and its XMSS signature on the assigned subnet. Several peers receive and forward it; assigned aggregators collect these messages.
  3. Assigned aggregatorsProve the collected signature checksAn aggregator produces an attestation aggregate and a STARK proof of its signers’ XMSS signatures. The aggregate records the votes and participants.
  4. Aggregators → CL peersBroadcast the aggregate and its proofP2P broadcast · multiple peersThe selected aggregator signs the aggregate wrapper and gossips it to CL peers under the draft’s timing and redundancy rules. One receiving CL is followed in the next steps.
  5. CL gossip validationValidate the incoming aggregateGossip validation checks the aggregate wrapper, eligibility and signature proof. These checks authenticate the votes before fork choice uses them.
  6. CL fork choiceApply the accepted head votesFork choice updates the signers’ latest messages. The checkpoint components of these attestations also feed Casper FFG after block inclusion.
  7. CL → ELCommunicate the selected execution-chain viewAs its chain view changes, the CL communicates the selected execution head to its paired EL through the Engine API.
Block proof and finality: the proposer merges the proofs

The pq draft allows attestation inclusion at least two slots after the attestation slot, giving the proposer time to receive aggregates and merge their proofs.

Participants
  • AggregatorsVotes + proofs
  • CLProposer side
  • CLReceiving node
  • ELPaired client
  1. Aggregators → consensus peers, including proposersSupply aggregates for block inclusionP2P broadcast · multiple peersAggregators publish their aggregates through gossip. Proposer CLs receive them through peer connections and select eligible entries for a later block. This is the aggregate publication also shown in the coupled-votes view.
  2. Proposer CLBuild one proof for the selected attestationsThe proposer merges the selected aggregates’ proofs into body.proof. Attestation entries in the block carry vote data and participants, without individual signatures.
  3. Proposer CL → consensus peersPublish an eligible later blockP2P broadcast · multiple peersThe proposer’s CL gossips the signed beacon block, including the selected attestations and their merged STARK proof, while respecting the minimum inclusion delay. The next steps follow one receiving CL.
  4. Receiving CLCheck the block’s signature statementsThe CL derives the XMSS verification statements from the included attestations and checks them against the block’s proof. It also validates the block and vote-processing rules.
  5. Receiving CLRecord checkpoint participationThe state transition records the included votes and their validators’ effective balances under Casper FFG rules.
  6. CLRecognize qualifying supermajority linksCheckpoint links backed by at least two-thirds of active stake can justify their targets under the FFG conditions.
  7. CLFinalize when the FFG conditions holdQualifying checkpoint links and epoch processing establish finality. This view compresses repeated voting rounds.
  8. CL → ELCommunicate the finalized execution chainThe CL passes the updated finalized execution-block reference to the EL through the Engine API.
PQ Decoupled Consensus
Voting structureSeparate head and finality messages
Finality clockSlot-based rounds; quorum-driven heights
Head: sampled committeeFinality: all active validatorsSignatures: leanXMSS
Block checks: CL duties and the separate payload path

The beacon block and execution payload have separate publication and validation paths. This view groups responsibilities; voting follows the protocol’s timing and payload-status rules.

Participants
  • CLProposer side
  • CLValidator’s node
  • ELPaired client
  • ValidatorSigning software
  1. Proposer CL → consensus peersGossip the beacon block to receiving peersP2P broadcast · multiple peersThe proposer’s CL gossips the signed beacon block, including selected consensus votes and their merged STARK proof. Peers forward it; the diagram follows one receiving CL. The execution payload is published separately.
  2. CLValidate the consensus blockThe CL checks the proposer’s XMSS signature, the included votes and their merged proof, together with the other consensus-state rules.
  3. CL → validatorPrepare a vote under the applicable rulesThe validator’s signing software receives a duty and eligible vote data from its CL. Voting uses the local consensus view and the protocol’s timing rules. In pq-dc, a head vote for the current-slot block carries PENDING payload status.
  4. CL → ELRequest execution validation on the payload pathWhen the separate payload is available and its envelope and data-availability checks pass, the CL asks its EL to validate execution.
  5. EL → CLReturn the execution resultThe EL executes and validates the payload. The CL tracks execution validity separately from receipt of the beacon block.
  6. CLMaintain the consensus view as information arrivesThe CL combines block, payload and voting information under the chosen consensus rules. The execution figure above expands the payload path.
Head votes: direct gossip and an aggregation path for blocks

Individual head votes reach fork choice directly. The draft also sketches head-vote aggregation for block inclusion; its proof details, aggregator selection and aggregate gossip still have TODOs. These paths overlap in time.

Participants
  • Head committeeSigners + their CLs
  • CLReceiving / proposer
  • AggregatorsSelection still open
  • ELPaired client
  1. Head committeeSign a head vote with leanXMSSA selected validator signs the block root and payload status using its per-slot head-vote leaf. A current-slot head carries PENDING payload status.
  2. Head committee’s CLs → consensus peersGossip the individual head voteP2P broadcast · multiple peersValidators’ CLs gossip individual signed head votes on the head_vote topic. Peers check the signature, committee membership, block reference and payload-status rules before using the vote.
  3. CL fork choiceUse recent votes, locks and merged proposal viewsThe available-chain rules combine recent votes and proposer-carried vote information with locks and finality-gadget constraints. A vote’s effect follows the protocol’s timing rules.
  4. CL → ELCommunicate the selected execution-chain viewThe CL updates its paired EL as its selected execution head changes.
  5. Consensus peers → aggregation participantsCollect compatible head votesAggregation participants also receive these head votes through gossip and group messages with the same slot, block root and payload status. Head-choice processing and collection for aggregation can overlap. Aggregator selection remains unfinished.
  6. Aggregation participantsConstruct the draft head-vote proofThe branch sketches a STARK proof of the grouped XMSS signatures. It explicitly leaves the head-vote proof design for further specification.
  7. Aggregators → proposer CLsMake the aggregate available to proposersProposed gossip · format still openThe intended aggregate-gossip path carries the head votes and their proof. Its message format and broadcast rules are still TODOs.
  8. Proposer CLCarry the proposal view into the blockThe proposer includes selected head-vote aggregates and support information. Their proofs join the finality-attestation proofs in the merged block proof shown in the next view.
Finality votes and the combined block proof

Finality attestations run on their own round schedule. The proposer merges proofs for the selected finality attestations and head votes into one block proof.

Participants
  • ValidatorsSigners + their CLs
  • AggregatorsSelection still open
  • CLProposer side
  • CLReceiving node
  • ELPaired client
  1. ValidatorsSign a separate finality attestationEach validator attests once per round with the XMSS leaf assigned to that round. Its message carries a target vote or timeout and may also support finalizing an earlier justification.
  2. Validators’ CLs → finality-attestation subnetPublish the individual finality attestationP2P broadcast · multiple peersValidators sign finality attestations, and their CLs gossip them on the assigned subnet. Aggregation participants collect them from this peer network. This duty has a separate schedule from head voting.
  3. Aggregation participantsProve compatible finality signaturesThe current helper groups attestations with the same data and round and proves their XMSS signatures. Aggregation across rounds remains a TODO.
  4. Aggregators → consensus peers, including proposersSupply aggregates for inclusionProposed gossip · format still openThe draft calls for aggregates with STARK proofs to be sent for block inclusion. Aggregate-gossip wrappers, selection and deadlines still need specification.
  5. Proposer CLHold valid finality attestations for proposersThe finality pool supplies candidate attestations. Only votes included in an accepted block contribute to its finality chain state.
  6. Proposer CLBuild one proof covering both voting dutiesThe proposer merges proofs for its selected finality attestations and head votes into body.proof. Both sets of entries in the block carry no signatures.
  7. Proposer CL → consensus peersGossip the block and its combined proofP2P broadcast · multiple peersThe proposer’s CL publishes the signed beacon block containing the selected finality attestations, head votes and their merged proof. Consensus peers receive and forward the block.
  8. Receiving CLValidate the published blockThe receiving CL checks the merged proof against the included finality and head votes, together with the proposer signature and the block’s other validity rules.
  9. Receiving CLAdvance justification and finality using included votesTarget-vote quorums justify targets; target votes and timeouts can advance a height after the required delay. Quorums for a pending justification’s finality pair finalize it. The draft uses validator weights adjusted for inactivity.
  10. CL → ELCommunicate the finalized execution chainThe CL passes its updated finalized execution-block reference to the EL. The available chain continues to respect the finality gadget’s constraints.

Where leanVM fits: both branches use leanXMSS signatures and STARK proofs of their verification. leanVM supplies the proving machinery discussed in this post; the specs describe the proof interfaces. The CL also enforces voting eligibility, participation and consensus rules.

PQ Gasper. Validators gossip one signed attestation carrying both head and checkpoint votes. Assigned aggregators prove the signature checks and gossip the aggregates. Proposers merge proofs for block inclusion. Receiving CLs use eligible votes for head choice and included checkpoint votes for Casper FFG finality, communicating the resulting execution-chain view to their paired ELs.

PQ Decoupled Consensus. Head votes and finality attestations follow separate schedules. Individual head votes reach CLs through gossip; aggregation also prepares votes for block inclusion. Proposers combine the selected head-vote and finality proofs, then gossip the block. Receiving CLs validate it, apply the head-choice and finality rules, and update their paired ELs. Several aggregate-gossip details remain open in this draft.

Read the complete flow as text

Each step names the participants, the action and what the message or proof means. These views group responsibilities; network activity and validation can overlap.

PQ Gasper
Block checks: CL duties and the separate payload path

The beacon block and execution payload have separate publication and validation paths. This view groups responsibilities; voting follows the protocol’s timing and payload-status rules.

  1. Gossip the beacon block to receiving peersProposer CL → consensus peers

    The proposer’s CL gossips the signed beacon block, including selected consensus votes and their merged STARK proof. Peers forward it; the diagram follows one receiving CL. The execution payload is published separately.

  2. Validate the consensus blockCL

    The CL checks the proposer’s XMSS signature, the included votes and their merged proof, together with the other consensus-state rules.

  3. Prepare a vote under the applicable rulesCL → validator

    The validator’s signing software receives a duty and eligible vote data from its CL. Voting uses the local consensus view and the protocol’s timing rules.

  4. Request execution validation on the payload pathCL → EL

    When the separate payload is available and its envelope and data-availability checks pass, the CL asks its EL to validate execution.

  5. Return the execution resultEL → CL

    The EL executes and validates the payload. The CL tracks execution validity separately from receipt of the beacon block.

  6. Maintain the consensus view as information arrivesCL

    The CL combines block, payload and voting information under the chosen consensus rules. The execution figure above expands the payload path.

Coupled votes: one attestation serves head and finality

Validators sign with leanXMSS. Each beacon committee has assigned aggregators with staggered collection and broadcast times in the pq draft.

  1. Sign one combined attestation with leanXMSSValidators

    The vote contains a head block and source and target checkpoints. A validator uses the XMSS leaf assigned to the target epoch.

  2. Publish the individual attestationValidators’ CLs → attestation subnet

    After signing, the validator’s CL gossips the SingleAttestation and its XMSS signature on the assigned subnet. Several peers receive and forward it; assigned aggregators collect these messages.

  3. Prove the collected signature checksAssigned aggregators

    An aggregator produces an attestation aggregate and a STARK proof of its signers’ XMSS signatures. The aggregate records the votes and participants.

  4. Broadcast the aggregate and its proofAggregators → CL peers

    The selected aggregator signs the aggregate wrapper and gossips it to CL peers under the draft’s timing and redundancy rules. One receiving CL is followed in the next steps.

  5. Validate the incoming aggregateCL gossip validation

    Gossip validation checks the aggregate wrapper, eligibility and signature proof. These checks authenticate the votes before fork choice uses them.

  6. Apply the accepted head votesCL fork choice

    Fork choice updates the signers’ latest messages. The checkpoint components of these attestations also feed Casper FFG after block inclusion.

  7. Communicate the selected execution-chain viewCL → EL

    As its chain view changes, the CL communicates the selected execution head to its paired EL through the Engine API.

Block proof and finality: the proposer merges the proofs

The pq draft allows attestation inclusion at least two slots after the attestation slot, giving the proposer time to receive aggregates and merge their proofs.

  1. Supply aggregates for block inclusionAggregators → consensus peers, including proposers

    Aggregators publish their aggregates through gossip. Proposer CLs receive them through peer connections and select eligible entries for a later block. This is the aggregate publication also shown in the coupled-votes view.

  2. Build one proof for the selected attestationsProposer CL

    The proposer merges the selected aggregates’ proofs into body.proof. Attestation entries in the block carry vote data and participants, without individual signatures.

  3. Publish an eligible later blockProposer CL → consensus peers

    The proposer’s CL gossips the signed beacon block, including the selected attestations and their merged STARK proof, while respecting the minimum inclusion delay. The next steps follow one receiving CL.

  4. Check the block’s signature statementsReceiving CL

    The CL derives the XMSS verification statements from the included attestations and checks them against the block’s proof. It also validates the block and vote-processing rules.

  5. Record checkpoint participationReceiving CL

    The state transition records the included votes and their validators’ effective balances under Casper FFG rules.

  6. Recognize qualifying supermajority linksCL

    Checkpoint links backed by at least two-thirds of active stake can justify their targets under the FFG conditions.

  7. Finalize when the FFG conditions holdCL

    Qualifying checkpoint links and epoch processing establish finality. This view compresses repeated voting rounds.

  8. Communicate the finalized execution chainCL → EL

    The CL passes the updated finalized execution-block reference to the EL through the Engine API.

PQ Decoupled Consensus
Block checks: CL duties and the separate payload path

The beacon block and execution payload have separate publication and validation paths. This view groups responsibilities; voting follows the protocol’s timing and payload-status rules.

  1. Gossip the beacon block to receiving peersProposer CL → consensus peers

    The proposer’s CL gossips the signed beacon block, including selected consensus votes and their merged STARK proof. Peers forward it; the diagram follows one receiving CL. The execution payload is published separately.

  2. Validate the consensus blockCL

    The CL checks the proposer’s XMSS signature, the included votes and their merged proof, together with the other consensus-state rules.

  3. Prepare a vote under the applicable rulesCL → validator

    The validator’s signing software receives a duty and eligible vote data from its CL. Voting uses the local consensus view and the protocol’s timing rules. In pq-dc, a head vote for the current-slot block carries PENDING payload status.

  4. Request execution validation on the payload pathCL → EL

    When the separate payload is available and its envelope and data-availability checks pass, the CL asks its EL to validate execution.

  5. Return the execution resultEL → CL

    The EL executes and validates the payload. The CL tracks execution validity separately from receipt of the beacon block.

  6. Maintain the consensus view as information arrivesCL

    The CL combines block, payload and voting information under the chosen consensus rules. The execution figure above expands the payload path.

Head votes: direct gossip and an aggregation path for blocks

Individual head votes reach fork choice directly. The draft also sketches head-vote aggregation for block inclusion; its proof details, aggregator selection and aggregate gossip still have TODOs. These paths overlap in time.

  1. Sign a head vote with leanXMSSHead committee

    A selected validator signs the block root and payload status using its per-slot head-vote leaf. A current-slot head carries PENDING payload status.

  2. Gossip the individual head voteHead committee’s CLs → consensus peers

    Validators’ CLs gossip individual signed head votes on the head_vote topic. Peers check the signature, committee membership, block reference and payload-status rules before using the vote.

  3. Use recent votes, locks and merged proposal viewsCL fork choice

    The available-chain rules combine recent votes and proposer-carried vote information with locks and finality-gadget constraints. A vote’s effect follows the protocol’s timing rules.

  4. Communicate the selected execution-chain viewCL → EL

    The CL updates its paired EL as its selected execution head changes.

  5. Collect compatible head votesConsensus peers → aggregation participants

    Aggregation participants also receive these head votes through gossip and group messages with the same slot, block root and payload status. Head-choice processing and collection for aggregation can overlap. Aggregator selection remains unfinished.

  6. Construct the draft head-vote proofAggregation participants

    The branch sketches a STARK proof of the grouped XMSS signatures. It explicitly leaves the head-vote proof design for further specification.

  7. Make the aggregate available to proposersAggregators → proposer CLs

    The intended aggregate-gossip path carries the head votes and their proof. Its message format and broadcast rules are still TODOs.

  8. Carry the proposal view into the blockProposer CL

    The proposer includes selected head-vote aggregates and support information. Their proofs join the finality-attestation proofs in the merged block proof shown in the next view.

Finality votes and the combined block proof

Finality attestations run on their own round schedule. The proposer merges proofs for the selected finality attestations and head votes into one block proof.

  1. Sign a separate finality attestationValidators

    Each validator attests once per round with the XMSS leaf assigned to that round. Its message carries a target vote or timeout and may also support finalizing an earlier justification.

  2. Publish the individual finality attestationValidators’ CLs → finality-attestation subnet

    Validators sign finality attestations, and their CLs gossip them on the assigned subnet. Aggregation participants collect them from this peer network. This duty has a separate schedule from head voting.

  3. Prove compatible finality signaturesAggregation participants

    The current helper groups attestations with the same data and round and proves their XMSS signatures. Aggregation across rounds remains a TODO.

  4. Supply aggregates for inclusionAggregators → consensus peers, including proposers

    The draft calls for aggregates with STARK proofs to be sent for block inclusion. Aggregate-gossip wrappers, selection and deadlines still need specification.

  5. Hold valid finality attestations for proposersProposer CL

    The finality pool supplies candidate attestations. Only votes included in an accepted block contribute to its finality chain state.

  6. Build one proof covering both voting dutiesProposer CL

    The proposer merges proofs for its selected finality attestations and head votes into body.proof. Both sets of entries in the block carry no signatures.

  7. Gossip the block and its combined proofProposer CL → consensus peers

    The proposer’s CL publishes the signed beacon block containing the selected finality attestations, head votes and their merged proof. Consensus peers receive and forward the block.

  8. Validate the published blockReceiving CL

    The receiving CL checks the merged proof against the included finality and head votes, together with the proposer signature and the block’s other validity rules.

  9. Advance justification and finality using included votesReceiving CL

    Target-vote quorums justify targets; target votes and timeouts can advance a height after the required delay. Quorums for a pending justification’s finality pair finalize it. The draft uses validator weights adjusted for inactivity.

  10. Communicate the finalized execution chainCL → EL

    The CL passes its updated finalized execution-block reference to the EL. The available chain continues to respect the finality gadget’s constraints.

Based on the experimental pq and pq-dc branches reviewed on November 20, 2026. In pq-dc, head-vote proof details, aggregator selection, cross-round aggregation and aggregate gossip remain unfinished. Playback groups responsibilities while the network’s voting, proving and payload paths overlap. See also the PQ block rules and PQ-DC block rules.

If readiness comes through PQ Gasper, DC would remain a possible later upgrade. If it comes through PQ DC, that structural change would already be in place. Either way, aggregation performance, networking, incentives and behavior under poor network conditions still need attention. Some aggregation may be necessary for the initial transition itself.

For operators, the practical questions are the same: can their setup keep up, what additional duties does it have, and what happens when messages or proofs arrive late? Faster finality would also benefit applications that currently wait for settlement or accept additional risk to serve users sooner. Realizing those benefits requires further work on vote timing, aggregation and network performance. [8]

Data availability: a scalable replacement for the fallback

If rollups had to stop using today's blobs and publish through calldata, that could preserve a way to operate while imposing higher costs and lower throughput. Restoring a dedicated PQ data path would therefore be a priority. A transition that delivers PQ blobs earlier could avoid that fallback.

With leanDA, blob data is encoded with extra redundancy so it can be reconstructed even if some pieces are missing. A prover generates a proof that this encoding and the commitments identifying the data were produced correctly. Nodes then request small pieces from the network and verify that they match those commitments. This sampling lets them assess availability without each node downloading every blob. [9]

The proof establishes that the data was prepared correctly. Sampling checks whether the network actually serves it. Both are necessary: correctly prepared data can still be withheld.

The EIP-8479 proposal connects that construction to Ethereum. It replaces KZG commitments and proofs with hash-based commitments, authentication paths and a leanDA proof, while retaining PeerDAS's sampling and custody structure. It also proposes carrying leanDA proofs as dependencies aggregated through EIP-8288. [10]

For L2 teams, this means a new publishing and verification path to integrate and test. It also shows why execution and DA cannot be planned in isolation: the proposed data path uses some of the same aggregation infrastructure as user transactions. Client integration, proof generation and network benchmarks remain part of the work.

Making the pieces work together

Moving aggregation into the mempool changes what nodes do with pending transactions. Some nodes would generate proofs as well as relay data, and builders would depend on those proofs arriving in time. Proving speed, peer connections and the choice of which proofs to fetch all affect whether that helps the network.

Csaba Kiraly's analysis of EIP-8288 networking makes these tradeoffs concrete. Under the study's simulated network conditions, larger PQ signatures could travel at the tested load without recursive mempool aggregation. Recursive aggregation opened possibilities for larger workloads and privacy proofs, but introduced costs that depended on who aggregated, how proofs were distributed and when peers fetched them. [11]

For us, that makes networking part of the design from the beginning. If users can only reach a block through a few powerful aggregators, the resource problem has consequences beyond transaction fees. We need to understand how the system works with different machines, uneven participation and failing peers.

From this series to the implementations

The work described here makes the transition useful at scale: accounts people can afford to use, consensus operators can sustain, and data capacity rollups can rely on. Reaching that point requires the components to work together, with implementations that have been tested and reviewed as carefully as the cryptography itself.

This closes our introductory series. We have covered the urgency, the risks, the preparation and the destination.

At LambdaClass, we are committed to implementing these changes in ethrex and ethlambda, working closely with researchers and other client teams. We will test them together on devnets, improve their performance, and publish our code and benchmarks. We will use those results to help refine the specifications as the designs evolve.

The next series will examine the mechanisms in more detail: frame transactions, our minimal proposal for native PQ signatures and its intended path to EIP-8288, and the full aggregation design. We will also dedicate a post to leanVM, explaining what it proves and how that work supports signatures, consensus and data availability.

Sources

  1. An Ethlabs view on post-quantum and post-AI timelines: pqai27.
  2. Dependency frames for leanSPHINCS signatures. LambdaClass draft proposal, PR #12672.
  3. EIP-8288: In-mempool signature and proof aggregation.
  4. Recursive-STARK-based bandwidth-efficient mempool.
  5. leanVM. design, implementation status and benchmarks.
  6. leanSPHINCS, leanSTARK and leanPCS. Vitalik Buterin, November 16, 2026.
  7. EIP-8453: Decoupled Consensus. Draft proposal, with experimental pq and pq-dc specifications.
  8. Upgrading Finality 1: Decoupling Consensus. EF Protocol Consensus.
  9. LeanDA: Design and Benchmark.
  10. EIP-8479: Post-Quantum PeerDAS and Variable-Size Blobs. proposal and open implementation questions.
  11. EIP-8288: the networking side of recursive aggregation. Csaba Kiraly.