EIP-8289 Multi-block access list warming

No call decision · Fees & gas · EIP status Draft · created 2026-05-03

Treats addresses and storage slots accessed within the last 256 blocks as warm from the start of the block, exempting them from the cold-access surcharge. Saves about 14% of block gas at the median.

Why it is needed

Today, Ethereum charges a cold-access surcharge each time a transaction first touches an address or storage slot. It costs about 2100 extra gas for a slot and about 2600 for an address, and this access record is cleared once the transaction ends. On mainnet, this surcharge accounts for 17% of block gas at the median. However, measuring 5,731 blocks showed that 79% of entries that paid the cold fee had already been accessed within the preceding 256 blocks (about 51 minutes). In effect, the same entries are repeatedly being charged a 'first time seen' fee. This EIP keeps a warm access multiset (WAM) as chain state that records entries accessed in the last 256 blocks, treating entries found there as warm from the start of the block, eliminating the duplicate charge. About 14% of block gas is saved at the median.

What changes

Today

After EIP-8289

Who is affected

In depth

The warm access multiset (WAM) and per-block transitions

WAM is chain-derived state mapping entries (a 20-byte address Account(addr), or a pair of an address and a 32-byte storage key, Slot(addr, key)) to a u32 counter. If WAM[item] > 0, that entry is warm. Before a block B's transactions execute, +1 is applied to each entry in ADD = items(BAL(B-1)), and -1 is applied to each entry in DEL = items(BAL(B-1-WARMING_WINDOW)), deleting entries that reach 0. ADD is applied before DEL so that an entry present in both does not briefly become 0, and the final WAM does not depend on the order of application. WARMING_WINDOW is 256 blocks (about 51 minutes at 12-second slots). Membership checks are O(1), and per-block updates are O(|BAL|). The BAL being evicted is authenticated via the EIP-2935 history contract (in the order of storage proof, block hash, and the header's block_access_list_hash), and since that block is WARMING_WINDOW + 1 blocks earlier, it falls within EIP-2935's 8191-block window.

SMT commitments and the new header field wam_root

WAM is committed as a binary sparse Merkle tree (SMT) of depth 256. leaf_key(item) = SHA256(serialize(item)), the leaf value is a u32 counter (0 if absent), and the root WAM_ROOT goes into a new 32-byte header field wam_root. Both the leaf keys and node hashes use SHA-256 (same as beacon chain SSZ merkleization, precompile 0x02). Per block, leaves are incrementally updated for as many items as are in ADD ∪ DEL, and inclusion/non-inclusion proofs are compressed to carry only about log2(|WAM|) sibling nodes rather than the default. Since WAM is deterministically derived from the chain of BAL commitments, wam_root is technically redundant, but without it a zkEVM prover would have to prove the 256-block transition inside the circuit or include the entire WAM as a witness, and a light client would have to download 256 BALs just to check whether a single item is warm. With wam_root, both cases collapse to a single compressed proof against the header.

Transaction initialization, gas pricing, reverts, and activation

At the start of every transaction, the access list is initialized with the existing entries (precompiles, tx.from, tx.to, the coinbase from EIP-3651, the EIP-2930 access list, the EIP-7702 authority list) plus every item for which WAM[item] > 0. No new gas constants are introduced. If the target is warm, both account and storage access cost 100 gas; if cold, account access costs 2600 gas and storage access costs 2100 gas, and the item is added to the transaction access list as in EIP-2929. WAM changes only via per-block transitions; transaction execution or reverts never modify WAM. During the first 256 blocks after activation, DEL is empty so WAM only grows monotonically, and steady state begins at activation_block + WARMING_WINDOW.

Why the window size is 256 blocks

Based on the median across a sample of 5,731 mainnet blocks, the tradeoff is as follows. At W=8 (96 seconds), 60% of cold operations become warm, saving 10.1% of gas at a WAM size of 0.6MB. At W=32 (6.4 minutes): 70%, 12.0%, 2MB. At W=128 (25.6 minutes): 78%, 13.3%, 6MB. At W=256 (51 minutes): 81%, 13.9%, 10MB. At W=512 (102 minutes): 84%, 14.3%, 18MB, with an asymptote at 17.5%. W=256 captures about 79% of the asymptotic gas savings at a WAM state cost of about 10MB, and sits 4x outside the finality window. Pushing further to W=512 triples the marginal cost per warm transition while only adding about 0.4 percentage points of savings, which the source describes as making W=256 the inflection point on the cost-effectiveness curve. It adds that memory-constrained implementations can choose W=8-32, implementations with headroom can go up to W=512, and beyond that efficiency degrades sharply.

Data structure choices: reference-counted multiset, SMT, SHA-256

Keeping the raw 256 BALs as-is and checking the union at query time makes membership checks O(256), while materializing the union as a set makes per-block updates expensive. A reference-counted multiset gives O(1) checks and O(|BAL_in| + |BAL_out|) updates, which is favorable on both paths, and recomputation cost on a reorg is identical across all three approaches. For the commitment, a binary SMT is used instead of a Merkle Patricia Trie (MPT). Because keys are determined by the regular structure of SHA256(item), non-inclusion proofs naturally fall out as a zero leaf along a deterministic path and the circuit is uniform, whereas MPT proofs have variable depth and require branch-sibling steps for non-inclusion. The hash function is SHA-256 rather than Keccak-256. In standard R1CS/BN254 arithmetization this costs about 25,000 constraints per hash (5,000-10,000 in lookup-based proving systems), cheaper than Keccak's roughly 150,000. If a ZK-friendly hash precompile such as Poseidon is introduced later, it can be swapped in without changing the structure.

Security: state growth, memory, reorgs

Adding an item to WAM still requires paying the same cold cost (2100 gas or more) as today, and the 2000-2500 gas savings accrue not to whoever added the item but to whoever accesses the same item afterward, so there is no economic incentive to bloat WAM. Empirically, WAM holds about 170,000 items at roughly 60 bytes each, around 10MB plus SMT internal nodes, which can be kept in memory alongside the existing node cache without needing a storage tier. The worst case is bounded by the block gas limit. A pathological block filled only with unique cold storage accesses adds about 16,000 items, so at W=256 the worst-case WAM is about 4 million items, roughly 250MB, though realistic mainnet workloads come nowhere close to this. On a reorg, since the transition is a deterministic function of the BALs, re-executing the new canonical chain restores WAM, and finality (2 epochs, about 12.8 minutes) bounds reorg depth to a small fraction of the warming window.

Backward compatibility and current status

This is a forward-only change. All existing transactions pay the same or less gas, and no transaction becomes invalid. EIP-2930 access lists remain valid and are idempotent even where they overlap with WAM. This EIP directly consumes EIP-7928's block access lists as the source of ADD and DEL, so EIP-7928 is a prerequisite; without it, a separate access-list commitment mechanism would be needed, which the source states is out of scope. The source's status is Draft, so the specification may still change, and test cases are yet to be added. There is no core developer call decision yet on which hard fork would include this.

Original EIP · ← EIPs