EIP-8101 Payload chunking using chunk access lists (Payload Chunking with Chunk Access Lists)

No call decision · Scaling & data · EIP status Draft · created 2025-12-01

Instead of propagating a block as a whole, this changes the block validation structure to a streaming approach that splits it into execution chunks and chunk access lists (CALs), propagates them separately, and validates them in parallel as they arrive.

Why it is needed

Today, to validate a single block, an Ethereum node must first download the entire execution payload and decompress it before it can begin execution. Because download, decompression, and execution proceed in sequence, this sequential dependency becomes a bottleneck for the consensus schedule as the gas limit rises and blocks grow larger. This proposal splits a block into multiple self-contained execution chunks and sends a Chunk Access List (CAL), which records how each chunk changes state, as a separate message ahead of time. State-change records are much smaller than transaction data, so they propagate quickly. Nodes can begin validating chunks as soon as they arrive without waiting for the entire block. An invalid block can be rejected immediately at the first invalid chunk. Chunk boundaries become a natural proving unit for future ZK proof systems. A block is still valid or invalid as a single unit; chunks are a construct used only during propagation and validation.

What changes

Today

After EIP-8101

Who is affected

In depth

Chunk structure and constants

A block is split into ExecutionChunks, and each chunk contains an ExecutionChunkHeader, a list of transactions, and a withdrawal list that appears only in the last chunk. The header contains the chunk's position (index), the CAL hash (chunk_access_list_hash), the cumulative values up to this chunk (pre_chunk_tx_count, pre_chunk_gas_used, pre_chunk_blob_gas_used), the transaction Merkle root (txs_root), the chunk's own gas_used and blob_gas_used, and withdrawals_root. The constants are the per-chunk gas limit CHUNK_GAS_LIMIT = 2**24 (16,777,216, a value taken from EIP-7825), the maximum chunks per block MAX_CHUNKS_PER_BLOCK = 2**8 (256), the maximum transactions per chunk MAX_TRANSACTIONS_PER_CHUNK = 2**16 (65,536), and the maximum CAL size MAX_CAL_SIZE = 2**24 bytes. The source's Rationale explains that 256 chunks at 16M gas each accommodates blocks of up to about 4Ggas.

The format and properties of the Chunk Access List (CAL)

A CAL is an RLP-encoded structure that narrows EIP-7928's Block Access List format down to the chunk level. For each account, it records storage writes (SlotChanges), a list of read-only slots, balance changes (BalanceChange), nonce changes (NonceChange), and code deployments (CodeChange) together with the transaction index. CALs have two properties. First, they are incremental: each CAL contains only the state changes made by its own chunk and does not repeat changes from earlier chunks, because a cumulative approach would create a bandwidth problem where CAL size grows in proportion to the number of chunks. Second, they are independent: each CAL can be validated on its own given only the pre-state. System contract records have fixed positions. The first CAL (chunk 0) contains pre-execution system writes (EIP-2935 block hash history, EIP-4788 beacon root), and the last CAL contains post-execution system operations (EIP-4895 withdrawals, EIP-7002/EIP-7251 validator operations).

Beacon block commitments and network messages

In the beacon block body, execution_payload is removed and replaced with execution_payload_header, and a chunk_count (uint8) field holding the number of chunks is added to the header. The body contains chunk_headers_root, a commitment to all chunk headers, and chunk_access_lists_root, a commitment to the CAL hashes. The execution layer uses EIP-7928-style keccak256(RLP(CAL)) in the chunk header, while the consensus layer uses SSZ hash_tree_root for inclusion proofs; both point to the same RLP-encoded CAL data. Chunks and CALs propagate on dedicated gossip topics named execution_chunk and chunk_access_list respectively, and each message carries a signed beacon block header plus a depth-13 SSZ Merkle inclusion proof. Without waiting for the full beacon block, a node can immediately verify the proposer signature, index range, gas limit, transaction root, and inclusion proof from the signed header alone, and then forward it. If EIP-7732 (ePBS) is enabled, the execution_payload field of the ExecutionPayloadEnvelope is replaced in the same way.

Chunk construction rules

Block producers must follow six rules. 1) Each chunk's gas_used must be at most CHUNK_GAS_LIMIT. 2) Minimum chunking: the combined gas of two consecutive chunks i and i+1 must exceed CHUNK_GAS_LIMIT, a rule meant to prevent unnecessary fragmentation that splits chunks that could otherwise be merged. 3) A transaction cannot be split across chunks and must belong entirely to a single chunk. 4) Withdrawals go only in the last chunk, and the withdrawal lists of all other chunks must be empty. 5) The number of chunks per block must not exceed MAX_CHUNKS_PER_BLOCK. 6) Chunk indices must be sequential from 0 to N-1.

Three-stage validation and attestation rules

The consensus layer directs verification. Phase 1 (CAL reception): after validating a CAL message, it is passed to the execution layer via engine_newChunkAccessListV1 to be cached. Phase 2 (chunk verification): chunk N executes only after CAL 0 through N have all arrived. The execution layer reconstructs the pre-state by applying CAL 0 through N-1 to the parent block state, checks that the CAL's hash matches the chunk header's chunk_access_list_hash, and then executes transactions in parallel using CAL N in the same manner as EIP-7928. Phase 3 (block finalization): once all chunks are valid, it checks that chunk N's pre_chunk_* fields match the accumulated values from chunk N-1, and that the final state root matches the payload header's state_root. Validators must not attest to a block before both phase 2 and phase 3 are complete. Under ePBS, the Payload Timeliness Committee (PTC) only attests that chunks and CALs arrived on time, independent of execution validity.

Four new engine API methods

Four methods are added to replace engine_newPayloadV5. engine_newBlockHeaderV1 delivers the block data minus the CAL and chunks (payload header, beacon root, blob hashes, execution requests) and must be called before the other methods. engine_newChunkAccessListV1 caches the CAL. engine_executeChunkV1 executes and validates a chunk once all preceding CALs are cached, and engine_finalizeBlockV1 checks header linkage, the final state root, and block header fields after all chunks have executed. All four methods return PayloadStatusV1, but the meaning of the status value differs by method. ACCEPTED means the header or CAL was successfully received, VALID means the chunk or block executed successfully, INSUFFICIENT_INFORMATION means a preceding CAL is missing (executeChunk only), INVALID means execution or validation failed, and SYNCING means the parent state is not yet held.

Data withholding attacks and countermeasures

Splitting a block into pieces for transmission creates a new attack surface. If a builder withholds some chunks, the block cannot be validated and attestation deadlines are missed; the countermeasures are attestation rules that require receipt of all chunks and a PTC that votes on availability. Withholding only the CAL blocks streaming execution but allows a fallback to sequential execution, since the CAL can be reconstructed by executing chunks in order. Sending chunks and CALs in reverse order (N down to 0) prevents parallel execution until chunk 0 and CAL 0 arrive, but the source explains that a rational builder has an incentive to propagate them in order to receive attestations quickly.

Current status: Draft

This EIP is in Draft status, created on December 1, 2025. The entire specification, including constants, data structures, and the engine API, may change during discussion. No decision has been made yet on which network upgrade would include it.

Original EIP · ← EIPs