EIP-8288: the networking side of recursive aggregation

author: Csaba Kiraly @cskiraly

EIP-8288, by Vitalik Buterin and Thomas Coratger, specifies the Recursive-STARK-based bandwidth-efficient mempool that Vitalik Buterin proposed in an earlier post on this forum. A transaction declares which post-quantum signatures and proofs it depends on. As transactions spread, mempool nodes fold those dependencies into recursive STARKs. A block carries one proof for all of them, so the EVM no longer checks each one separately. The mempool becomes a proving network. Whether it keeps up depends on what nodes send, how often they send it and how many peers receive it.

Post-quantum signatures alone don’t force this on the network. Our simulations show that today’s mempool can carry today’s load with them. At 15 signature tx/s, a little below today’s rate, nodes announced and fetched raw transactions as they do for large transactions today. One builder received and included them all. Other nodes uploaded about one copy of each transaction on average, or about 0.4 Mbit/s with 2.5 kB signatures and 1 Mbit/s with 7,740 B signatures. What we study here is how recursive aggregation goes beyond that. It offers a way to carry privacy transactions whose STARK witnesses are too big to gossip as transactions are today, and to scale beyond today’s design and workload.

We built a discrete-event simulator to explore EIP-8288’s networking choices. We varied who aggregates, what travels raw or in a proof, when nodes fetch and fold, and how fast they prove. We can change one choice at a time and run the same transactions on the same network. Across networks of 100 to 10,000 nodes, we measured how much these choices change inclusion, delay and upload before a specification fixes them. We have shared results with EIP-8288’s authors since August 2026 and presented our first results at Devcon 8’s P2P Networking Hub.

To the best of our knowledge, one other effort is working on EIP-8288’s networking in parallel. EIP-8437 starts with the wire protocol. Nodes announce wrappers and peers fetch them by hash. The two efforts will meet. A wire protocol has to settle choices such as when a peer fetches a proof. EIP-8437 itself notes that “propagation within the aggregation interval requires measurements”.

We report our results so far and four choices we think the two EIPs should spell out. First Questions has the details behind these numbers.

TL;DR

Most of our results turn on choices EIP-8288 leaves open. They concern how many peers receive each proof, which nodes aggregate, how raw transactions reach them and which prover the interval is set for. Our reference network has 1,000 nodes, each with six peers and a 25 Mbit/s uplink.

  • Today’s mempool can carry today’s load with post-quantum signatures. At 15 signature tx/s, nodes announced and fetched raw transactions on their way to one builder. The builder included every transaction at both signature sizes. Other nodes uploaded about one copy of each, averaging 0.4 Mbit/s with 2.5 kB signatures and 1 Mbit/s with 7,740 B signatures. The payload grows either by the signatures themselves or by one proof folded from them. Propagating a larger payload calls for protocols such as SEACAST. We study what recursive aggregation adds for privacy transactions and for scale.
  • Recursive aggregation also carries today’s load, at a standing upload cost set mostly by the number of peers. We modelled EIP-8288’s text on master without its per-wrapper caps. At 20 and 30 signature tx/s, on a prover as fast as leanVM’s benchmark machine, every transaction was included under the EIP’s interval. Mean delay was 7.7–8.3 s, against an ideal of 6 s. At 15 signature tx/s, pushing proofs to six peers every interval cost 11.9–13.3 Mbit/s per node across the 100- and 1,000-node networks. At 2 tx/s, push still cost 10.5 Mbit/s at 1,000 nodes. In design 4, nodes announced which transactions each proof covered. Peers fetched a proof if their next fold would take it. Upload then followed demand, falling from 7.9–8.1 Mbit/s at 15 tx/s to 2.4 at 2 tx/s. EIP-8288 should specify a small number of peers to push proofs to. While a node sends one wrapper per interval, as the EIP specifies today, each peer costs about 2 Mbit/s whatever the load. EIP-8437 should say when a node fetches a proof.
  • Who aggregates determines privacy capacity. When only some nodes aggregate, the way raw transactions reach them matters too. On the same prover, we added privacy transactions to 15 signature tx/s. With every node aggregating, all five designs held at least 72 privacy tx/s. With a quarter aggregating, capacity ranged from 6 to at least 72 privacy tx/s, depending on the design. One builder with ordinary mesh connections held 3–9 privacy tx/s. EIP-8437 should say when a node fetches a raw transaction, when it waits for a covering proof and how long a requester waits before asking another peer.
  • The prover determines whether 1,000 ms is enough. A node needs seven nested proofs to merge its own aggregate with those of its six peers. Our model prices the merge at 783 ms on leanVM’s benchmark machine and 2,252 ms on four cores of a laptop-class Ryzen. The EIP’s interval held every load in our interval runs on leanVM’s benchmark machine. On four Ryzen cores it held none of the loads with privacy transactions. Spare compute or bandwidth alone did not help. EIP-8288 should say which prover its interval is set for.
  • The main results also hold at 10,000 nodes, about mainnet’s size. At today’s load, mean inclusion delay grew by 0.6 s. Four of the measured capacities changed.

EIP-8288 for networking people


Figure 1. Each interval a node folds the raw transactions and peer proofs it holds into one proof and sends it to its peers. A proof can therefore cover more transactions at each hop. The builder folds the proofs it receives into one block proof. The figure omits the path raw transactions take between nodes.

  • A transaction has a body and a witness. The witness is a signature or a STARK submitted by the user. We call a transaction with a user STARK a privacy transaction, after the protocols EIP-8288 has in mind. A proof is a recursive STARK. Its coverage is the set of transactions it proves.
  • Users send mode 0 wrappers. These carry transactions with the witnesses themselves. We call a transaction with its witness a raw transaction.
  • Nodes send mode 1 wrappers. Every AGGREGATION_INTERVAL (1,000 ms in EIP-8288), a node folds what it holds into one recursive STARK. Nodes then “forward this wrapper object to their peers”. The wrapper carries the proof, identifies the transactions it covers and includes their bodies. A hash takes the place of any body the node has already sent.
  • Peers can also fetch wrappers by hash. In the proposed EIP-8437 wire protocol, nodes announce each wrapper’s mode, length, hash and two digests of its coverage. Peers fetch the wrappers they want, including users’ mode 0 wrappers.
  • The EIP gives a fold order for when proving time runs short. The node takes its own previous aggregate first, then removals. Next it takes peers’ aggregates in order of how many new transactions they add, then users’ transactions by priority fee. “Nodes may also alternate between adding one object at a time” from the last two groups.
  • The builder folds the proofs for the transactions it includes into one block proof. The EIP puts the builder’s STARK overhead at “a fixed ~256 kB per AGGREGATION_INTERVAL”. It describes the networking overhead as “constant per peer”. With pushed wrappers, a node sends one proof to each aggregation peer every interval and receives one from each.

Why sizes make it a networking problem

For post-quantum signatures, the number of copies matters. EIP-8288 puts hash-based signatures at ~2–3 kB. The leanSPHINCS scheme proposed for frame transactions uses 7,740 B, compared with 65 B for ECDSA (#12616). We modelled signatures of 2,560 B and 7,740 B. At 15 tx/s, each copy a node sends or receives costs 0.31 Mbit/s at the smaller size or 0.93 Mbit/s at the larger one.

Geth pushes a transaction of up to 4,096 B in full to ⌈√peers⌉ peers that it doesn’t know to have the transaction. At its default limit of 50 peers, that means eight full copies and announcements to the rest. For larger transactions, geth announces to all peers and each fetches one copy. Under today’s limit, a 2.5 kB signature would travel like a small transaction and cost about 2.5 Mbit/s in signature bytes at 15 tx/s and 50 peers. A 7,740 B signature would travel by announcement and fetch. We expect clients to retune the limit for post-quantum signatures and fetch transactions at either size, at a cost of one copy per node.

Privacy witnesses are too large to gossip the way transactions are today. EIP-8288 describes user STARKs of 128–512 kB. We modelled 256 KiB. At just one privacy transaction a second, each copy costs 2.1 Mbit/s. Geth’s propagation rules call for announcement only at that size, and its legacy pool refuses transactions over 128 KiB. With aggregation, the witness can travel in a proof.

On chain, a signature costs more to carry than to check. EIP-8288 estimates that contract code uses about 150,000–200,000 gas to check a hash-based signature. The protocol check proposed in pull request #12616 costs 12,600 gas. At EIP-8141’s calldata floor of 64 gas per byte, a plain transfer with a 7,740 B signature costs about 0.53M gas. A 60M-gas block holds about 113 such transfers. For comparison, over a day of mainnet blocks we found a median of about 390 transactions in blocks that were at least 95% full.

EIP-8288 takes the signature out of the block. The transaction carries a 96-byte reference and pays a fixed 33,000 gas for its share of the block proof. For a STARK, verification in the EVM costs many millions of gas.

With EIP-8288 the mempool also changes its networking paradigm. Today’s nodes pass on what they receive unchanged. An EIP-8288 node combines what it receives and passes on the result. Networking people know this as in-network aggregation, or as data fusion, sensor fusion and in-network processing, and have studied it in sensor networks and datacentres. Two things set this use apart from that literature.

  • Bodies and proofs take different paths and need to meet. Transaction bodies travel unchanged. Signatures and privacy witnesses travel together in proofs. A builder needs both the body and the proof of its witness, and can only include a proof if it has the bodies the proof covers. At a minimum, transaction hashes connect the two paths. Announcements might also carry the senders and nonces that EIP-8077 adds.
  • Merging takes proving time. For a sum, a count or a maximum, merging two partial aggregates is practically free. Here every merge requires a recursive proof. Folding two proofs into one takes 303 ms on leanVM’s benchmark machine. Our model prices a merge of six peers’ aggregates and a node’s own at 783 ms out of a 1,000 ms interval. The number of peers a node can merge therefore depends on both the interval and the prover.

Longer term, transactions can move from the body path to the proof path. The execution proof in Rapidblocks with split proofs binds to its inputs and outputs in place of a state root. It stays valid as long as its inputs remain unchanged.

Once a transaction or group of transactions is executed and proved this way, it can travel as a proof that nodes merge like any other. The network can build a block in parts. That leads to more granular public block building and gives another way to provide FOCIL-like censorship resistance. We don’t model split proofs here.

The simulator

We built stark-mempool-sim, a discrete-event simulator of EIP-8288, in a fork of George Kadianakis’s repository of the same name.

What it models: a transaction’s path to a block

A transaction reaches a block in five steps.

  1. Entry. A user submits a raw transaction to a random mempool node.
  2. Delivery to an aggregator. If the entry node aggregates, it can prove the transaction. Otherwise the transaction must travel to an aggregator with its witness.
  3. First fold. The aggregator folds the transaction into its own aggregate.
  4. Propagation. The aggregator sends its aggregate to its aggregation peers. A peer that aggregates can extend its own coverage by taking the incoming aggregate as a nested proof, a proof verified inside its fold. A peer that doesn’t aggregate passes the proof on.
  5. Selection. At the slot boundary the proposer selects from the objects it holds. In the model, the block includes every transaction covered by the selected proofs. That is our simplification: EIP-8288 lets a builder choose the transactions and fold just their dependencies into the block proof. We limit the number of objects selected and impose no block gas limit. The model stops at selection, so the delay excludes execution, proving the block and delivering it.

We measure four quantities.

  • Inclusion is the share of arriving transactions that a block includes. We say a configuration holds a load if every seed includes at least 95% of all transactions. Signature and privacy transactions count together. For example, with a quarter of the nodes aggregating, push holds 6 privacy tx/s even though the runs include only 84–88% of the privacy transactions.
  • Inclusion delay is the mean time from entry to block selection (step 5) for the transactions included. Arrivals are evenly spaced. Inclusion in the next block therefore gives an ideal mean delay of 6 s, half a 12 s slot.
  • Upload counts every byte a node sends, across all message types, as a rate over the 60 s of load.
  • CPU busy measures the share of those 60 s that the modelled prover spends proving or verifying, averaged over nodes.

How it is built

One clock and a common seed let us compare designs. The simulator schedules arrivals, deliveries, folds, timeouts and slot boundaries in simulated time. It represents a proof by the set of transactions it covers, its proving time and its size, without running cryptography. A seed fixes the network and the transactions for both designs in a comparison. We ran configurations on 4 or 8 seeds. The ranges include the spread across seeds unless we specify that they compare means.

Each node has an uplink queue and a prover queue. The uplink sends a separate copy to each recipient. It gives the mempool the full 25 Mbit/s and refuses messages that won’t fit in the 4 MB send queue. We chose the rate as a reference. EIP-7870 recommends 25 Mbit/s for an attester’s whole node, both clients together, 15 Mbit/s for a full node and 50 Mbit/s for a local block builder. The prover takes one proving or verification job at a time. We leave downlinks and memory unlimited.

All messages share one mesh. Raw transactions, announcements, requests and proofs use the same random network. Each node has six peers and each link has a delay of 100 ms (±10%). We chose six as a reference because it is gossipsub’s default. Ethereum’s consensus layer runs gossipsub at eight.

Each block has a budget of six objects. At each 12 s Ethereum slot boundary, the proposer can select up to six proofs or raw transactions. A proof can cover many transactions. We chose this tight budget for the model and also ran with a 501-object limit to find where selection limits inclusion. Every node learns of the block at once, at no cost.

We varied the network size and kept the runs short. We ran networks of 100 to 3,000 nodes, most often 1,000. We also ran the full fold-timing comparison at 10,000 nodes, about the number of reachable nodes on mainnet. At that size we tested the five transport designs at today’s load and around their capacity limits. Each run has five slots of arrivals and two slots to drain, which keeps comparisons across hundreds of runs affordable. Network size and run length are choices we made for these experiments.

What we varied

Table 1 links each choice to the step where it affects a transaction. We can vary any one of these choices while holding the others fixed.

Step Choice What we ran Why
1 Load 10–60 tx/s with none, a fifth or half private. Separately, 15 signature tx/s plus a privacy load rising to 72 tx/s Today’s load and above
1 Signature size on the wire 2,560 B or 7,740 B EIP-8288 estimates ~2–3 kB. The scheme in #12616 uses 7,740 B
2 Who aggregates Every node, a randomly placed quarter, or one builder. With a quarter aggregating, the other nodes relay their best proof. The single builder proves everything and proposes every block EIP-8288 has every mempool node prove. Fewer might participate, down to one
2 Raw transaction propagation The five designs in Table 2 EIP-8288 gives no raw relay step. EIP-8437 announces and fetches. Geth pushes small transactions
3 When to fold Ticks of 1,000 ms or 2,000 ms, or tickless. A tickless node folds whenever ready, with a proving budget of up to 2 s for its inputs The EIP’s interval, twice that interval, or no tick
3 Prover speed A 2→1 fold (two proofs into one) in 303 ms or 871 ms The fast prover models leanVM’s M4 Max benchmark machine. The slower one models four cores of a laptop-class chip
3 Cost to fold a privacy witness One or two nested proofs We estimate the cost because leanVM can’t prove this input yet
4 Proof propagation Push to every aggregation peer every interval, or announce coverage and let peers fetch EIP-8288 describes push. EIP-8437 announces and fetches, using digests where we use coverage lists
All Network size 100, 300, 1,000 and 3,000 nodes. Also 10,000 for fold timings and for transport at today’s load and around capacity Sizes we have tested so far

Table 1. The networking and proving choices we varied, by step in a transaction’s path to a block.

We set the share and placement of aggregators in each scenario. The model leaves out incentives to aggregate and concentrations of aggregators at builders or gateways.

We tested selected combinations of the choices in Table 1.

  • At 1,000 nodes we compared fold timings, provers and loads with every node aggregating and raw transactions pushed to every peer.
  • At 100 and 1,000 nodes we tested all five transport designs with every node aggregating, a quarter aggregating and one builder. All used the fast prover and the EIP’s tick. We repeated each run with a block budget of up to 501 objects to distinguish transport limits from proposer selection limits.
  • We used earlier proving prices to study network size and to vary the share aggregating from all nodes to a tenth.

The five transport designs differ in what a node sends and when it asks. From design 1 to 2, and from 2 to 3, one rule changes at a time. Design 4 changes both proof propagation and the decision to fetch a raw transaction. Design 5 applies geth’s current rules to the same six peers. Geth rounds the square root of the peer count up, so a small transaction goes in full to 8 of 50 peers at the default limit and 3 of 6 here. In all five designs, bodies come with the proof that covers them.

Design Raw transactions Proofs
1, push Push to every peer except the sender Push to every aggregation peer every interval
2, pull Announce by hash. Fetch unseen transactions with a 500 ms request timeout Push
3, keep Aggregators fold raw transactions and keep them at the node. Relays announce and fetch them Push
4, coverage As in design 3, but wait 3 s after the first announcement. Fetch only if no proof held or seen announced covers the transaction Announce coverage. Fetch a proof 400 ms before the fold if the next fold would take it
5, geth’s rules For transactions up to 4,096 B, push to 3 of 6 peers and announce to the rest. Announce larger transactions. Fetch 500 ms after the first announcement with a 5 s timeout Push

Table 2. How nodes send and fetch raw transactions and proofs in each of the five designs.

Design 4 uses coverage information for two decisions. A peer reads the list of transactions covered by an announced proof. It fetches the proof if its next fold would take it, and skips a raw transaction fetch if an announced proof covers the transaction.

EIP-8437 also uses announcements and fetches, with three differences from design 4. Its announcements contain two digests of the transactions. A requester skips the fetch only for a wrapper it already holds and has validated. Nodes announce every validated wrapper, including mode 0, whereas design 4’s aggregators keep raw transactions at the node. To reach design 4’s results, EIP-8437 would need per-transaction coverage metadata, as we proposed in Marchhill/EIPs#13. It would also need a rule for when an announcement can stand in for a fetch and a policy for forwarding mode 0 wrappers.

We tested design 4 with honest nodes. When a proof request times out, the requester drops that announcer as a source. When no announcer remains, it fetches the raw transaction. An announced proof that the node never requests can still hold back the raw fetch. Skipping fetches on the strength of announcements would need an expiry and limits on repeated offers. We haven’t tested those rules.

The proposer’s position matters when only some nodes aggregate. In the transport capacity runs we drew a proposer at random each slot, except in the single-builder scenario. With a quarter of the nodes aggregating, a relay therefore proposed about three slots in four. In the other runs a fixed aggregator proposed every block. With every node aggregating, drawing the proposer at random left inclusion unchanged and moved mean delay by at most 1.4 s wherever a design held 72 privacy tx/s.

Prices, and what is left out

Proving prices come from leanVM timings. We use prices for the proving time and bytes the simulator charges. We timed leanVM commit 990b935 of 28 October 2026 on pinned cores of a laptop-class Ryzen 9 8945HS. We scaled the timings to leanVM’s own M4 Max benchmark, where a 2→1 fold takes 303 ms. At that speed, the model charges 25.9 ms per proof plus 108.2 ms per nested proof and 1.667 ms per leanSPHINCS signature folded into it. A proof occupies 224–262 KiB depending on the work the fold commits to. Verification costs 9.2 ms.

For the slower prover, we scaled every proving price to a 2→1 fold of 871 ms on four Ryzen cores. A newer leanVM benchmark (e4dcb8d5, 11 November) reports 154 ms for a 2→1 fold in a different configuration. We haven’t recalibrated against it. We identify earlier runs that used prices from leanVM cycle counts. First Questions gives the calibration and its known errors.

The signature-size comparison changes only the wire size. At both wire sizes, including 7,740 B, we use the same proving price, measured for the 4,276 B leanSPHINCS signature in 990b935. We haven’t measured the proving cost of the scheme in #12616.

The cost of folding a privacy witness is an estimate. We interpret the EIP’s ~256 kB as 256 KiB on the wire and charge one nested proof to fold a witness, or two in some runs. leanVM can’t yet take that input. EIP-8288 reserves its STARK scheme until a dependency digest is defined for it. Our privacy runs model the extension the EIP intends.

We lift the per-wrapper caps in EIP-8288’s text on master. Master caps a wrapper at 16 signatures and one STARK. In our model one wrapper covers every active transaction. EIP-8437 is written against #12590, an open update to EIP-8288 by EIP-8437’s first author. The update lets nodes split their pools across several mode 1 wrappers. It provisionally limits each wrapper and each block to 256 dependencies, including at most 16 STARKs. A block could then include at most 16 privacy transactions, or 1.3 per second, well below the loads we tested.

Model limits. We leave out execution, nonces and transaction order, so inclusion is an upper bound. We also leave out adversaries, FOCIL and fees beyond a scalar. We don’t time the block proof or block delivery (step 5), so building a block can’t make it late in the model. Unless we specify otherwise, folds follow the EIP’s stated input order. Each stage stops at the first input that won’t fit.

Validation. The published replay shows that the results are reproducible. We haven’t checked the model’s predictions against an execution client or a testnet.

What we found

Today’s mempool carries today’s load, even with post-quantum signatures

One builder with raw transactions announced and fetched (design 2) is the closest of our runs to how we expect today’s mempool to handle post-quantum signatures. Only the builder proves, and it proposes every block. At 15 signature tx/s, a little below today’s load, it included every transaction at both signature sizes on networks of 100, 1,000 and 10,000 nodes. Its prover was about 15% busy.

Each node other than the builder uploaded about one copy of each transaction. These nodes sent no proofs, and each node fetched each transaction once. During the load, non-builder upload averaged 0.39–0.40 Mbit/s with 2,560 B signatures and 0.99–1.01 Mbit/s with 7,740 B signatures, or 2–4% of the uplink. The busiest such node uploaded 0.6 Mbit/s at the smaller size and 1.4–1.6 Mbit/s at the larger one. Adding peers would increase only the announcement traffic.

Delay depended on network size. Mean inclusion delay was the same for both signature sizes. It rose from 7.0–7.6 s at 100 nodes to 7.4–8.0 s at 1,000 and 7.9–8.4 s at 10,000, against an ideal of 6 s. The model’s six peers put more hops between a transaction and the builder than a real node’s 50 peers would.

Geth’s current rules distinguish between the two sizes. With 2,560 B signatures, a node pushed each small transaction to 3 of its six peers and uploaded 0.78 Mbit/s. Transactions waited 6.5–7.7 s for inclusion. With 7,740 B signatures, nodes announced the transactions and waited 500 ms before each fetch. Upload was 0.93–0.97 Mbit/s. Mean delay was 8.5–9.4 s at 100 nodes and 11.1–11.7 s at 10,000.

Post-quantum signatures alone therefore fit today’s load on the network without mempool aggregation. The block still grows. A builder that folds the signatures, as ours did, adds one proof. A builder that includes the signatures adds their bytes at the gas cost described above. Propagating the larger payload calls for protocols such as SEACAST. We turn next to what recursive aggregation adds for privacy transactions and for scale beyond today’s design and workload.

With recursive aggregation today’s load works too, at a standing cost

We used 20 and 30 tx/s to bracket today’s load. Mainnet averaged 21.3 tx/s over the 30 days to 10 November 2026 and 23.3 tx/s over the last seven. Daily means ranged from 17.8 to 25.3 tx/s in ethPandaOps’ Xatu data for canonical blocks.

At both test rates, with signature traffic only, every fold timing included every transaction at 1,000 nodes (the top row of each grid in Figure 3). Under the EIP’s tick, the fast prover was 37–41% busy and mean inclusion delay was 7.7–8.3 s. At 10,000 nodes all three timings still included every transaction on both provers. Mean delay on the fast prover under the EIP’s tick rose to 8.3–8.9 s.

Pushing proofs makes upload depend mainly on peer count. EIP-8288 has a node send a fresh proof to each aggregation peer every interval. While its pool has transactions, even very few new ones, the node needs roughly this much upload for proofs alone.

peers × proof size ÷ interval

The original proposal gives the arithmetic. Sending 128 kB every 500 ms to 8 peers costs 2 MB/s. We checked the formula in simulation with leanVM’s proof sizes and the EIP’s interval. At 1,000 nodes on earlier leanVM prices, wrapper bytes on each link matched the formula within 2% at degrees 4, 6 and 8. None of the wrapper encodings we tried reduced the standing cost. They can suppress a proof a peer already has, but each interval produces a new one.

With proofs of 224–262 KiB and an interval of 1,000 ms, six peers cost 11–13 Mbit/s. The 8 peers in the original proposal’s example cost 15–17 Mbit/s. EIP-8288 specifies no peer count. The upload a node needs makes that count a protocol parameter.

Two provisions could reduce the cost. EIP-8288 already lets a node whose pool contains only signatures concatenate them in a mode 0 wrapper. The EIP says this takes less space than a proof up to about a hundred signatures. An open update, #12595, lets an aggregator reuse a proof of the same dependencies. The aggregator can use a proof it holds or wait up to two intervals for an announced one. A peer may then already have the proof the aggregator would send.

We tested a narrower form of reuse at 100 nodes. A node adopted a peer’s proof if it covered everything the node’s next fold would add. Adoption occurred 2–217 times per run and left inclusion unchanged. We haven’t modelled the wait in #12595 or its partitioning of candidates to make more proofs match. Both #12590 and #12595 also allow a node to split transactions across several wrappers. Each extra wrapper costs as much again.

Fetching proofs makes upload follow demand. In design 4, a peer uses announced coverage to fetch only the proofs its next fold would take. Table 3 compares the upload and delay of all five designs with every node aggregating. Upload counts every message sent during the 60 s of load.

Design Upload at 15 signature tx/s (Mbit/s) Upload at 2 signature tx/s (Mbit/s) Mean delay at 15 signature tx/s (s)
1, push 13.2–13.3 10.5 7.0–7.4
2, pull 12.5 8.9–10.5
3, keep 11.9–12.1 10.3–12.3
4, coverage 7.9–8.1 2.4 10.3–12.5
5, geth’s rules 12.6 8.1–9.4

Table 3. Upload per node and mean inclusion delay when every node aggregates. At 15 signature tx/s the ranges span 100 and 1,000 nodes. Each value for a given network size is a mean over 8 seeds. At 2 tx/s we ran only designs 1 and 4, at 1,000 nodes.

Reducing the load from 15 signature tx/s to 2 at 1,000 nodes cut upload by about a fifth with push and by 70% with design 4. Upload was much the same at 10,000 nodes. There, at 15 signature tx/s, the designs that pushed proofs used 11.7–13.2 Mbit/s per node and design 4 used 7.7 Mbit/s; at 2 tx/s, push used 10.5 Mbit/s and design 4 used 2.3 Mbit/s.

Fetching also reduced upload when only a quarter of the nodes aggregated. At 15 signature tx/s across the 100- and 1,000-node networks, design 4 used 2.9–3.0 Mbit/s per node. The designs that pushed proofs used 11.7–12.5 Mbit/s.

Fetching proofs added little delay when every node aggregated. Design 3 keeps raw transactions at aggregators and pushes its proofs. Its mean delay was at most 0.2 s shorter than design 4’s. How raw transactions travelled accounted for the delay differences.

When raw transactions had to travel to an aggregator, design 4 added 3.9–5.4 s over design 3 with a quarter aggregating and 8.0–12.5 s with one builder. In the one-builder case design 4 fetched no proofs, so its extra delay came from raw transaction propagation. We haven’t isolated the effect of waiting 3 s before each raw fetch.

Larger signatures increased delay while inclusion held. With 7,740 B signatures, all three fold timings included every transaction up to 60 signature tx/s at 1,000 and 10,000 nodes, with raw transactions pushed to every node. At 15 signature tx/s, designs 1, 4 and 5 also included every transaction under all three ways of sharing the work.

The larger signatures used more of the uplink. At 1,000 nodes under the EIP’s tick, increasing signatures from 2,560 B to 7,740 B raised uplink use from 57% to 73% at 20 tx/s and from 63% to 87% at 30 tx/s. At 45 and 60 tx/s the larger signatures used 96–97% of the uplink. Mean delay increased by 0.8–3.6 s at 1,000 nodes and 1.0–4.5 s at 10,000. In the transport comparison, push uploaded about 3.1 Mbit/s more per node. Under geth’s rules nodes announced the larger signatures and peers fetched them. Transactions waited 1.8–4.3 s longer than with the smaller signatures.

How raw transactions travel

A recursive proof can cover hundreds of privacy transactions in about the bytes of one raw privacy witness. The open question is how far the raw transaction has to travel before a node proves it. EIP-8288’s node algorithm gives no step for relaying a user’s mode 0 wrapper. EIP-8437 has nodes announce mode 0 wrappers for peers to fetch. A node should suppress the announcement to a peer if a proof they have already exchanged covers the transactions.

We measured privacy capacity by adding a rising privacy load to 15 signature tx/s. We tested all five designs under the three ways of sharing the work, up to 72 privacy tx/s at 100 and 1,000 nodes. Across the capacity tests the load rose in steps of 3–24 privacy tx/s. We report the highest step that passed the inclusion threshold with all lower steps also passing. Only the steps around each capacity limit ran on every seed. We count untested lower steps as passing.

Capacity here is a short-run threshold. Near the limit, a backlog may still be growing after 60 s of arrivals. Where the highest tested rate passed, the result gives a lower bound on the short-run capacity. Figure 2 shows the range of thresholds across seeds.


Figure 2. Privacy capacity on top of 15 signature tx/s at 100 and 1,000 nodes. The panels show who aggregates. Each range spans 8 seeds. An arrow means the design held the highest rate tested.

With every node aggregating, transport barely limited privacy capacity on the fast prover. Designs 2–5 held at least 72 privacy tx/s at both network sizes. Push held at least 72 at 1,000 nodes and 36–54 at 100.

Keeping each raw transaction at its entry node makes inclusion depend on that node alone. Only the entry node can first prove the transaction. That dependence matters if nodes can be slow or hostile, neither of which we tested here.

With a quarter aggregating, the transport design decided capacity. A transaction entering at a relay must travel raw to a node that can prove it. Figure 2’s middle panel shows how much privacy load each design held.

  • Pull was sensitive to the request timeout. On one 1,000-node network with a fixed proposer, increasing design 2’s timeout from 500 ms to geth’s 5 s raised capacity from 12 to 36 privacy tx/s. The timer starts as soon as a node queues the request. With up to 1.28 s of uplink traffic ahead of it, a request can time out before it leaves. This was pull’s weakest network, and waiting 5 s cost inclusion elsewhere. No fixed timeout performed best everywhere.
  • Fold order changed design 4’s capacity. A design 4 node asks for proofs its next fold would take. At 1,000 nodes with one fixed proposer, ranking inputs by fee per unit of proving cost held 54 privacy tx/s. The EIP’s order held 36–54.
  • Geth’s rules carried the most privacy traffic in this comparison. Their 5 s timeout does not explain the result. We haven’t isolated the effects of pushing small signature transactions, batching requests and allowing one request in flight per transaction.
  • Block size and seed usually changed capacity by at most one load step. Raising the block budget to 501 objects could move capacity up or down by at most one step. The spread across seeds was at most one step except for keep at 1,000 nodes with 501-object blocks, which held 27–54 privacy tx/s. Fixing the proposer gave a wider spread in five series because its position varied across networks.

One builder held 6–9 privacy tx/s in the designs that announced raw transactions. Push held 3–6. With every node aggregating, the corresponding capacities were at least 72, except for push at 100 nodes (36–54). The single builder was an ordinary mesh node. It received all transactions through six peers, proved them all and proposed every block. Its 25 Mbit/s uplink was half the rate EIP-7870 recommends for a local block builder. The runs added privacy transactions to 15 signature tx/s and charged 256 KiB and one nested proof per privacy witness.

We couldn’t separate two limits in the builder scenario. Its 1,000 ms fold had room for its own aggregate and about eight privacy witnesses. The other nodes also had to upload the witnesses. At 12 privacy tx/s, pull, keep and geth’s rules all missed the inclusion threshold with six-object blocks. The builder’s prover was 84–95% busy and the other nodes’ uplinks averaged 87–96% busy.

  • Transport and block size. With six-object blocks, pull, keep and geth’s rules each held 9 privacy tx/s at both network sizes. Design 4 held 6–9 and push held 3–6. With 501-object blocks, geth’s rules and keep reached 12, though keep ranged from 9 to 12 at 1,000 nodes. Design 4 also reached 12 at 100 nodes.
  • Proving speed. Under pull, making the prover a thousand times faster gained one step, to 12 privacy tx/s, in two of the four cases tried on one network seed. None held the next step. In earlier runs priced by cycle counts, push held 3 privacy tx/s with one builder. A prover a thousand times faster left that capacity unchanged.
  • Delay. At 15 signature tx/s, design 4 had the longest mean wait for one builder, 15.2 s at 100 nodes and 20.1 s at 1,000. The other designs took 6.6–7.6 s.

At 10,000 nodes most capacities matched the 1,000-node results. We used six-object blocks and tested only the step at each capacity limit and the step above it.

  • With every node aggregating, all five designs still held 72 privacy tx/s.
  • With a quarter aggregating, push still held 6 privacy tx/s and geth’s rules at least 72. Design 4 rose from 36–54 to 72. At 96 privacy tx/s it included 83–88% of all transactions. At 54 privacy tx/s a node uploaded 6.5–7.1 Mbit/s, down from 14.1–14.6 at 1,000 nodes. We haven’t isolated the reason. We didn’t run pull or keep with a quarter aggregating at this size.
  • With one builder, push still held 3–6 privacy tx/s and keep held 9. Design 4 held 3–6, down from 6. Pull and geth’s rules each held 6–9, down from 9 at 1,000 nodes. A prover a thousand times faster under pull still missed 12 privacy tx/s, including 90–93% of all transactions.

Adding nodes increased capacity while a node’s proving work stayed flat. In the earlier runs priced by cycle counts, every node aggregated and nodes pushed raw transactions to every peer. The 100-node networks held 9 privacy tx/s and the 3,000-node networks held 18, with unchanged prover occupancy per node. First Questions gives those runs. With the timed prices, prover occupancy also stayed flat from 1,000 to 10,000 nodes, while mean delay grew by 0.4–0.9 s.

Not every node has to aggregate

On the earlier proving prices, even a tenth of the nodes aggregating was enough at the loads we tried. We tested shares from all nodes down to a tenth at 1,000 nodes, with raw transactions pushed to every node and an aggregator proposing. Every share included at least 96.9% of transactions.

A relay acting as proposer could run short of proofs. With a quarter aggregating, none of the proposer’s six neighbours aggregated on 5 of the 28 networks. The proposer starved on those networks unless relays forwarded only their best proof, the one covering the most live transactions. This rule is a heuristic for honest networks. It can strand a proof that covers transactions missing from the best proof. First Questions gives the sweep and its figure.

Whether the interval is enough depends on the prover

A node on a fixed tick must fit its fold into one interval. If time runs short, EIP-8288 lets the node take fewer inputs in the order the EIP specifies. A merge of six peers’ aggregates and the node’s own needs seven nested proofs. On the fast prover the model charges 783 ms for the merge, leaving 217 ms of the EIP’s 1,000 ms interval. At our baseline price each raw privacy witness adds the cost of another nested proof.


Figure 3. Inclusion on the worst of 8 seeds at 1,000 nodes, by load and privacy share. From left to right the grids compare fold timings. The upper grids show the fast prover and the lower grids show four Ryzen cores. Green cells hold the load. Dashed boxes mark today’s load.

On the fast prover, all three fold timings held every load in Figure 3. We tested up to 60 tx/s with as many as half the transactions private, pushing raw transactions to every node. Every load held with either one or two nested proofs per privacy witness. The same was true at 10,000 nodes.

The 2,000 ms tick achieved that inclusion with half the proofs and half the CPU of the 1,000 ms tick. At 20 and 30 signature tx/s the prover was 17–18% busy, down from 37–41%. Transactions waited no longer for inclusion. Mean delay was 7.4–7.5 s on the longer tick and 7.7–8.3 s on the EIP’s tick. Under privacy load, mean delay stayed within a second of the EIP’s tick in either direction.

On four Ryzen cores the EIP’s tick held only signature traffic. At the slower prover’s 871 ms price for a 2→1 fold, a seven-proof merge costs 2,252 ms. That exceeds even the 2,000 ms interval. The lower grids of Figure 3 show the results at 1,000 nodes. With one nested proof per privacy witness, we found the following limits.

  • The 1,000 ms tick included every transaction with no privacy load, up to 60 tx/s. Mean delay was 1.8–3.5 s longer than on the fast prover. The tick held none of the privacy loads we tested. Across those loads, inclusion on the worst seed ranged from 9% to 62%.
  • The 2,000 ms tick held 10 and 20 tx/s with a fifth private. At 20 tx/s the worst run included 95.1%.
  • Tickless held both of those loads and also held 10 tx/s with half private.
  • No timing held a privacy load at 30 tx/s or above.

Charging two nested proofs per privacy witness reduced the loads that held on four cores. The 2,000 ms tick and tickless held only 10 tx/s with a fifth private. The EIP’s tick still held no privacy load.

At 10,000 nodes the longer tick and tickless included more transactions on four cores. Their average gains over 1,000 nodes were 6 percentage points with a fifth private and 12 points with half private. Under the EIP’s tick, every cell kept its rating of held, marginal or collapsed. With a fifth private it included 61–69% at 10 tx/s and 33–40% at 20 tx/s.

  • The 2,000 ms tick now held 10 tx/s with half private at either one or two nested proofs per witness.
  • Tickless now held 20 tx/s with half private at one nested proof per witness, and 10 tx/s with half private at two.
  • At 20 tx/s with a fifth private, the 2,000 ms tick was close to the 95% threshold at both sizes. Inclusion was 93.8–99.6% at 10,000 nodes and 95.1–98.7% at 1,000.
  • No timing held a privacy load at 30 tx/s or above.

We haven’t isolated why more nodes help the slower fold timings.

The four-core limit was how much a fold could take in during one interval. At our mean 2→1 timing of 871 ms, a 1,000 ms fold has room for the node’s own aggregate and one peer’s. A third nested proof would miss the deadline by 7.5 ms. At the median timing of 845 ms the third proof fits. Under privacy load the interval budget stopped 96.6–99.7% of folds on four cores.

Fitting a third proof didn’t help in the three loads we reran at 845 ms, with a fifth private and one nested proof per witness. At 20 tx/s, inclusion was 21–35% at 845 ms, against 34–38% at 871 ms. At 45 tx/s the figures were 11–18% and 18–25%. At both loads, every run at 845 ms included fewer transactions than the run on the same network at 871 ms. At 10 tx/s the ranges overlapped, 55–81% against 62–70%. At 10,000 nodes every run included fewer transactions at the faster timing at all three loads.

The likely explanation is the remaining room for signatures. At 845 ms a fold that takes a second peer’s aggregate has room for about 4 signatures instead of about 70.

We tested the interval budget separately from prover speed and bandwidth. The controls used 10, 20 and 45 tx/s with a fifth private and gave the same result at 10,000 nodes.

  • A prover three times as fast still fell behind when we cut its fold budget to 348 ms. Each fold then admitted as many inputs as on four cores, and the fast prover was only 36–37% busy. With the full 1,000 ms budget it held those loads.
  • Uplinks ten times as fast also fell behind.
  • Letting folds run past the interval and queue behind one another put the network further behind.

These narrow folds still kept up with signature-only traffic. With privacy traffic, neither spare compute nor bandwidth alone rescued the EIP’s interval on four cores.

Tickless held every load the 2,000 ms tick held on either prover, at a cost. At 20 and 30 signature tx/s on the fast prover at 1,000 nodes, tickless kept the prover 94–96% busy and the uplinks 99% busy. Mean inclusion delay was 12.4 s, rising to 14.5 s at 10,000 nodes.

Inclusion delay

Inclusion delay runs from entry into the mempool to selection of the block carrying the transaction’s proof. A transaction waits for a node to fold it, for the aggregate to travel to the proposer, and for the next block. Each hop can cost up to one fold interval.


Figure 4. Mean inclusion delay at 1,000 nodes on the fast prover, by load, privacy share and fold timing. The dotted line marks the ideal mean of 6 s if every transaction makes the next block.

Most signature transactions made it into a block within 12 s. At 20 and 30 signature tx/s under the EIP’s tick, mean delay on the fast prover at 1,000 nodes was 7.7–8.3 s (Figure 4). The ideal is half a 12 s slot, or 6 s. Of the transactions entering the mempool, 81–86% were included within 12 s and all within 24 s.

Privacy traffic increased delay at the same total rates. We pushed raw transactions to every node and priced each privacy witness at one nested proof. Mean delay rose to 12.1–13.4 s, and 38–49% of transactions were included within 12 s. With signatures only, switching to four Ryzen cores gave a mean delay of 9.7–10.3 s. Keeping the fast prover and increasing signatures to 7,740 B gave 8.5–9.4 s.

Moving to 10,000 nodes added 0.6–1.8 s to those mean delays. At today’s load with the fast prover and baseline signatures, the mean was 8.3–8.9 s. Within 12 s, 76–81% of transactions were included, and all were included within 24 s. The means count only included transactions, so they understate delay where a design falls behind.

What we think the EIPs should say

Four choices that the EIPs leave open changed the outcome of our runs. They sit where the two efforts meet.

  1. EIP-8288 and EIP-8437 should specify what bounds a node’s wrapper upload. Under EIP-8288, pushing one wrapper to each of D peers every interval requires at least D × proof size ÷ interval in upload while the pool is active. EIP-8288 should name a degree D for wrapper exchange, separate from the transaction-gossip peer set, as gossipsub does for its mesh. Treat the degree, interval and proof size as one budget.

    Under EIP-8437, upload depends on what peers fetch. The EIP sets a serving budget but leaves open when and what a node fetches. Specify when to fetch a proof and include the information a requester needs in the announcement. Two digests can’t tell a node how many new transactions an overlapping proof adds. We proposed per-transaction coverage metadata in Marchhill/EIPs#13.

  2. EIP-8437 should specify when to fetch a raw transaction and how to set the request timeout. Once only some nodes aggregate, the path raw transactions take decides capacity. EIP-8437 has nodes announce mode 0 wrappers to every peer and has a requester try another announcer after a timeout. Say when the node should fetch the raw transaction and when it should wait for a proof that covers it. We’d set the timeout according to when the requester needs the object, whether a proof or a raw transaction. We haven’t tested that rule.

  3. EIP-8288 should name the prover its interval is set for and say what a slower node should do. To merge its own aggregate with those of D peers, a node must fit D + 1 nested proofs into one interval. On leanVM’s benchmark machine the modelled 1,000 ms interval held every load in the interval grid. On four cores of a laptop-class Ryzen it held no load with privacy transactions. Spare compute or bandwidth alone did not help.

  4. EIP-8288 should say what a fold does when an input doesn’t fit. The EIP allows both its stated input order and alternating between peer aggregates and users’ transactions. It leaves open whether a node stops at an input that exceeds the remaining budget or passes over it. Folding a privacy transaction costs a whole nested proof at our baseline price. A signature costs far less, so the decision changes which transactions wait. Order also matters. Changing the order changed design 4’s capacity with a quarter aggregating at 1,000 nodes. On four cores a slightly faster prover included fewer transactions under the strict order.

Code and data

The simulator lets us compare a proposal with the designs here on the same networks and transactions. The bounds in #12590 or the proof reuse in #12595 could each be added as another choice.

We used version 2.5 of the simulator fork, tagged first-questions-v11. The code, run configurations and data behind each figure are in eth-networking-studies at tag eip-8288-networking-2.