Ethereum researchers have reported that a new segmented broadcasting design could greatly speed up the delivery of large execution payloads.
In a simulated test, a 1 MiB payload reached half of the network in about 0.75 seconds when split into smaller pieces. Sending the same payload as one large message took around five seconds.
The research focuses on EIP-8411, which divides execution payloads into smaller chunks that Ethereum nodes can verify and forward before receiving the entire payload.
Each chunk includes a Merkle proof connected to a Merkle root in the execution bid. This allows nodes to check individual pieces and start forwarding them while the rest of the payload is still arriving.
The current draft proposes 64 chunks and replaces the single execution payload gossip topic from EIP-7732 with an execution payload chunks topic.
The researchers tested the system using 500 simulated nodes, geographic network delays, 50 Mbps upload speeds and 100 Mbps download speeds. The test used real Prysm and go-libp2p-pubsub code running on a simulated network.
With the full payload sent as one message, the median propagation time was about five seconds, while the slowest nodes took close to six seconds. With the tuned segmented design, the median dropped to around 0.75 seconds and the tail was close to one second.
The researchers also found that the segmented approach required about one-third more received data than the current system. This is because nodes handle many separately identified pieces and additional control messages.
A second version of the design aims to reduce duplicate network traffic. Instead of sending every chunk to all eligible peers, nodes can send pieces to a smaller group and let other peers request missing pieces when needed.
The researchers also tested a system called disciplined pulls. A node first requests a chunk from one peer and switches to another source if the first peer does not respond within a set time.
For a 1 MiB payload, this approach reduced received traffic to about 1.5 copies of the payload per node. However, it also created a new risk because a malicious or overloaded peer could announce a chunk and then fail to provide it. Tests showed that withholding chunks could increase tail latency.
A third version adds Reed-Solomon erasure coding. This allows the payload to be rebuilt after enough pieces are received, even if some original pieces are missing.
The coded version produced the lowest tail latency in the tests and continued working when some chunks were withheld. The tradeoff was higher bandwidth use at the source because extra parity data had to be sent.
EIP-8411 is still a draft and is not an active Ethereum feature. The proposal was opened on Sept. 4 and remains under review.
Developers are now considering whether to include it in Hegotá, the Ethereum upgrade expected after Glamsterdam. A discussion about the proposal was scheduled for Sept. 17 at the All Core Developers Consensus call, but no inclusion decision had been recorded at the time of the report.
EIP-8411 was proposed as a replacement for EIP-8142, which explored putting blocks into blobs but faced concerns around builder-side KZG proving and the reuse of data-availability subnets.
The proposal is connected to Ethereum’s broader effort to increase Layer 1 capacity. Larger gas limits can create larger execution payloads, which means validators need to receive and process more data within fixed network deadlines.
Researchers have also released experimental prototype code for Prysm and go-libp2p-pubsub. The code includes a segmented payload gossip mode and the forwarding and request systems used in the tests.
However, the researchers stress that the prototype is only a testing tool and not the final proposal. Some advanced features, including erasure coding, remain experimental.
Several questions still need to be addressed, including higher control-message traffic, CPU costs from handling more small messages, queue management, timer settings and possible changes from newer QUIC-based networking.
For now, the research shows that splitting large execution payloads into smaller, independently verifiable pieces could significantly reduce propagation times in simulated networks. But the results are still experimental, and Ethereum developers must decide whether the approach is ready for inclusion in Hegotá.
