EIP-7898 Separating the execution payload from the beacon block (Uncouple execution payload from beacon block)
No call decision · Scaling & data · EIP status Stagnant · created 2025-03-01
The execution payload containing transactions is split off from the beacon block and transmitted over a separate channel. Only a summary header of the payload remains in the beacon block.
Why it is needed
Ethereum has a goal of significantly raising the gas limit, which determines per-block processing capacity, potentially up to 10x. Currently, entire transactions are contained within the beacon block, so as blocks grow larger, the networking and block-processing pipeline of consensus layer (CL) clients grows heavier as well. The original text points to two problems. First, block arrival latency increases and beacon nodes require greater bandwidth. Second, as the number and size of transactions increases, merkelization computation time increases, lengthening block import time. It is known from timing-game cases that delayed block import makes it harder for validators to attest to the correct head. This EIP resolves congestion in the block transmission and import paths, allowing the beacon block to be processed concurrently even while a large execution payload is still being received.
What changes
Today
- The entire transaction set is included in the BeaconBlockBody as an ExecutionPayload
- As blocks grow larger, propagation latency and merkelization computation time both increase
- Consensus clients must store and serve blocks containing transactions
- Separate types exist for blinded blocks (BlindedBeaconBlock, etc.) and regular blocks
After EIP-7898
- The beacon block contains only the ExecutionPayloadHeader, and the payload is propagated separately on its own topic together with an inclusion proof (ExecutionPayloadWithInclusionProof)
- The beacon block can be processed concurrently while a large payload is being received
- Consensus clients no longer need to store and serve blocks containing transactions, reducing resource burden
- The blinded and regular versions merge into a single type, simplifying the API and code paths
Who is affected
- Consensus client teams: Changes to the BeaconBlockBody structure, a new gossip topic, and availability-check logic must be implemented. In exchange, block storage burden decreases and blinded types disappear, simplifying the code.
- Execution client teams: Support for the newPayloadHeader engine API is required, and optionally a getExecutionPayload-style feature for quickly retrieving payloads over P2P can be added.
- Validators: If block import congestion decreases, voting for the correct head becomes easier. However, a block received via gossip must wait for payload availability before it is imported into fork choice.
- Builders and relays (PBS participants): While the proposer propagates the signed block directly over P2P, builders and relays independently disclose the payload, making the pipeline more efficient. The submitBlindedBlock API response also changes.
In depth
Replacing ExecutionPayload with ExecutionPayloadHeader in BeaconBlockBody
The core change is replacing the ExecutionPayload field in BeaconBlockBody with ExecutionPayloadHeader. Since transaction data moves outside the beacon block, the block itself becomes smaller, and transactions are excluded from the merkelization computation. The block import mechanism itself is not changed, with the sole exception that waiting for the ExecutionPayloadWithInclusionProof is added to block availability determination. The original text explains that this is a simpler distinguishing point compared to proposals like ePBS or APS.
Independent propagation of ExecutionPayloadWithInclusionProof and builder API changes
The ExecutionPayloadWithInclusionProof is computed by the block proposer or builder and propagated independently on a separate new gossip topic. Its link to the header contained in the beacon block is verified via an inclusion proof. The builder's submitBlindedBlock API is also modified to respond with an ExecutionPayloadWithInclusionProof. In the PBS pipeline, efficiency improves as the proposer sends the signed block directly over the P2P network while leaving independent disclosure of the payload to builders and relays.
Availability checks apply only to gossip import
A wait for the availability of the corresponding ExecutionPayloadWithInclusionProof is added to the data availability check for fork choice import, but this applies only to blocks received via gossip. For checkpoint sync or range sync, the execution layer (EL) can pull the full block from peers as it does today, so EL optimistic sync is allowed. To support this, a newPayloadHeader engine API is introduced to complement the existing use of newPayload for processing blocks without an ExecutionPayload (such as range sync blocks), and this call notifies the EL to optimistically sync that payload over the EL P2P network.
Optional getExecutionPayload and EL-driven propagation
The EL may optionally introduce a getExecutionPayload method similar to getBlobs, letting a peer that has seen a new VALID payload announce the payload hash so that others can recover the payload more quickly over the EL P2P network. The mechanism by which EL clients independently participate in delivering and receiving large execution blocks can be developed separately and is outside the scope of this EIP.
Why the SignedExecutionPayload alternative was not chosen
One design alternative considered was SignedExecutionPayload and SignedExecutionPayloadHeader, signed by the builder (or by the validator, in the case of local block building). This approach has the advantage of allowing the payload to be transmitted before the header is even included in the beacon block, which could significantly reduce latency between the proposer and builders/relays, especially in the PBS pipeline. However, without the builder being explicitly enshrined in the protocol, strictly validating gossip for SignedExecutionPayload is difficult and could become a DOS attack vector, so the inclusion proof approach was chosen instead.
Long-term outlook: ZK proofs and data availability sampling
The original text explains that, as an additional benefit, once zero-knowledge (ZK) proofs of EL block execution become available in the future, nodes will be able to treat transactions like blobs. Just as blobs confirm data availability via data availability sampling (DAS), transactions will also be able to have their validity confirmed without re-execution. This points toward a direction where nodes no longer need to import all transaction data, allowing L1 execution itself to become rollup-like.
Compatibility and current status
This change is not backward compatible, so activation requires a new hard fork. The original text's specification details, test cases, reference implementation, and security considerations are left as TODO, with the security section stating only that discussion is needed. The current status of this EIP is Stagnant, meaning the content is incomplete and there is no guarantee it will proceed as is.