EIP-8159 eth/71 block access list exchange (eth/71 - Block Access List Exchange)
No call decision · Networking & nodes · EIP status Last Call · created 2026-02-12
Adds two request/response messages to the Ethereum p2p protocol so nodes can exchange block access lists (BALs), and adds a BAL hash field to the block header.
Why it is needed
EIP-7928 introduces the Block-level Access List (BAL), which records every state location touched during block execution. With this list, disk reads and transaction execution can be processed in parallel, and state can be updated without directly executing the block. However, for a syncing node to gain this benefit, it needs to obtain the BAL from somewhere. Currently, the consensus layer only passes the BAL via the Engine API during normal operation; there is no way to obtain the BAL of a past block or use it for peer-based syncing. This EIP fills that gap by adding BAL request/response messages to the eth p2p protocol. It also adds the BAL's hash to the block header so that a received BAL can be verified as genuine.
What changes
Today
- A BAL can only be obtained when the consensus layer passes it via the Engine API during normal operation
- There is no way to request the BAL of a past block from another node
- The block header has no hash with which to verify a received BAL
After EIP-8159
- BALs can be requested from and received by peers using the GetBlockAccessLists and BlockAccessLists messages
- The authenticity of a received BAL is verified by checking it against the block-access-list-hash in the block header
- A syncing node can take advantage of the BAL for parallel disk reads and parallel execution
Who is affected
- Client teams: The new protocol version eth/71 must be implemented. This requires adding the header field, handling the two messages, and logic to verify the hash of received BALs.
- Node operators: BALs can be received from peers and used during sync. Older clients can keep using eth/69 or eth/70, so nothing breaks immediately.
- Ordinary users: Nothing changes directly. It indirectly benefits from improved efficiency in node syncing and block processing.
In depth
Block header extension
Adds a block-access-list-hash (B_32) field after requests-hash in the block header. The value is the keccak256 hash of the RLP encoding of the block access list defined in EIP-7928, i.e. keccak256(rlp.encode(block-access-list)). This field MUST be present in block headers from the Amsterdam fork onward, and MUST NOT be present in blocks before that.
The RLP encoding structure of the BAL
A BAL is a list of per-account changes (account-changes), sorted by address in ascending order. Each account-changes entry consists of address, storage-changes, storage-reads, balance-changes, nonce-changes, and code-changes. storage-changes MUST be sorted by ascending slot, with changes within each slot sorted by ascending block-access-index, and storage-reads MUST also be sorted by ascending slot. block-access-index marks the point of change: 0 is the pre-execution system contract call, 1...n are transactions in block order, and n+1 is the post-execution system contract call and withdrawals. BAL generation rules and inclusion semantics follow EIP-7928.
GetBlockAccessLists (0x12)
Sends a list of block hashes in the form [request-id: P, [blockhash1: B_32, ...]] to request the BAL for those blocks. The implementation determines the limit on how many BALs can be requested in one message. BALs are only available for blocks after EIP-7928 activation and only within the retention period it defines. Requests for BALs that cannot be provided get an empty entry in return.
BlockAccessLists (0x13) and the 2 MiB soft limit
A response in the form [request-id: P, [block-access-list1, ...]], with each element corresponding to the request's block hashes in the same order. Blocks without a BAL return the RLP empty string (0x80). The recommended soft limit on the response is 2 MiB, consistent with existing eth responses such as blocks, receipts, and headers. This limit is only a threshold for stopping the addition of further entries, not a maximum size for an individual entry, so a response containing a single BAL larger than 2 MiB is still valid.
Obligation and cost of validating a received BAL
A client that receives a BAL MUST compute keccak256(rlp.encode(bal)) and verify it against the block-access-list-hash in the corresponding block header. A typical BAL averages about 70 KiB, so this hash computation cost is negligible, and even the worst case at a high gas limit is bounded by the block gas limit.
Why a separate message instead of the block body
There are three reasons for sending the BAL as a dedicated message instead of including it in the block body. First, since a BAL averages about 70 KiB, bundling it into the body would substantially increase the block propagation burden. Second, not every sync strategy needs a BAL; snap sync can reconstruct state without one. Third, block bodies are retained for longer, but BALs may be pruned earlier under EIP-7928's retention policy. Message IDs 0x12 and 0x13 continue the numbering from BlockRangeUpdate (0x11), the last message in the existing eth/69.
Security considerations
A small request can trigger a much larger response, creating potential for amplification attacks. Implementations SHOULD rate-limit requests and respect the soft response size limit. They MUST also handle empty responses gracefully, since a peer that returns an empty entry for an available block could be malicious, but could also have legitimately pruned the data after its retention period expired.
Status and deployment conditions
This EIP is in Last Call status with a last-call-deadline of 2026-11-01. Since it is not yet Final, its contents may still change. Deployment happens through the rollout of a new protocol version, eth/71, and since supporting multiple protocol versions simultaneously is standard practice, older clients can keep using eth/69 or eth/70. Extending the header field requires the Amsterdam hard fork, and the new messages are only meaningful for blocks after Amsterdam.