EIP-3584 Block access lists (Block Access List)
No call decision · Scaling & data · EIP status Stagnant · created 2021-05-22
A proposal to aggregate the per-transaction access lists declared by EIP-2930 into a single block-level list, and to include its fingerprint (hash) in the block header for verification.
Why it is needed
Currently, each transaction can pre-declare which addresses and storage keys it will access via an EIP-2930 access list, but this information is not aggregated at the block level, so it cannot be used for anything beyond a single transaction. If the addresses and keys actually accessed by every transaction in a block were aggregated, it would provide a hint for identifying access-conflict-free regions across transactions for parallel execution, and it would let light-sync or fast-sync clients that only care about certain addresses fetch and verify just the parts they need instead of the whole block. It could further be extended into an index for bundling and distributing the witness data needed for stateless verification. To actually realize these benefits, the block-wide access list must be built according to a fixed, canonical rule that everyone produces the same result from, and a fingerprint guaranteeing the content has not changed must be included in the block header for verification.
What changes
Today
- Each transaction has an EIP-2930 access list, but these are not aggregated at the block level
- A light client interested in only certain addresses or state must download the entire block
- Access conflicts between transactions within a block cannot be known in advance, so there is no parallel-execution hint
After EIP-3584
- An access_list is constructed that aggregates the access records of every transaction in the block
- AccessListRoot, the hash of the access_list, is included in the block header and verified
- An index sorted by address and transaction index enables partial lookups, parallelization hints, and future witness-data distribution
Who is affected
- Client teams: When validating a block, the access_list must be reconstructed and the AccessListRoot recomputed to confirm it matches the value in the header.
- Validators (node operators): Block processing gains the additional work of generating the access list and computing its hash.
- Developers of light-sync and stateless protocols: They can use this index to selectively fetch and verify access information only for the addresses they need.
- Wallet & app developers: There is little direct impact for now, but it can be leveraged once future witness-data extensions are built.
In depth
access_list structure
An access_list is a set of access_list_entry items. Each entry is a 3-tuple [address, storage_keys, accesses_by_txn_index], where address is a 20-byte address and storage_keys is a sorted list of the 32-byte storage keys accessed for that address across the whole block. accesses_by_txn_index is a list of [txn_index, storage_keys] 2-tuples sorted by txn_index, indicating which transaction accessed which keys. Validation rules require that each address appear only once in the access_list, each storage_key appear only once in that address's storage_keys, and each txn_index appear only once in accesses_by_txn_index.
How the AccessListRoot is generated
AccessListRoot is a URN-like string of the form "urn:sha256:json:0x${hash}". The hashing scheme (sha256) and serialization scheme (json) are made explicit in the name: the canonical access_list is turned into a JSON string, hashed with SHA256 into a 32-byte value, and appended as a hex string prefixed with 0x. This URN form was chosen so that if the construction is later changed to a merkle tree, verkle tree, or kate commitment, only the name needs to change, to something like urn:merkle:... or urn:kate:..., without touching the block structure itself.
Additional block validation rules
Once this EIP is adopted, validating a new block adds a check that the AccessListRoot recomputed from the access_list produced by actually executing the block matches the value recorded in the block header. In other words, the AccessListRoot in the header is not mere metadata but a value that must be reproducible from the result of block execution.
Motivation: parallelization, light sync, witness extension
The original text cites three benefits of a block access_list. First, it enables optimization, parallelization, and cache warming for block execution and validation: building a partial order (poset) from the access records allows the chains within it to be processed in parallel. Second, light-sync or fast-sync protocols interested only in a particular set of addresses can fetch and check just part of the block data and state. Third, this list could be extended into an index for bundling, serving, and fetching witness data for stateless protocols.
Why this sort order and the AccessListRoot were chosen
The access_list is sorted lexicographically or by integer order internally. Sorting by access time was also considered, but it was judged to only increase implementation complexity and bookkeeping cost without additional benefit, so it was not adopted. The AccessListRoot is included in the block header and verified in order to prevent griefing attacks. It is currently defined as a simple SHA256 hash, but the explanation notes that evolving it into a structure like a merkle/verkle tree or a kate commitment would be advantageous for enabling partial download, inspection, and verification.
Future extension: possible inclusion of witness data
The original presents a future version that extends the access_list structure by adding an AddressWitnesses list for each address and a StorageKeyWitnesses list for each storage key. It explains that this would make it easier to bundle or request witness data using this access_list, creating a staged path toward partial or full statelessness. However, the canonical specification for this extension has not yet been defined.
Activation timing, preconditions, and current status
The added block validation only becomes mandatory from the block number at which this EIP takes effect; before that, clients may generate or provide this access list via the JSON-RPC API, but this is optional and implementations may vary across clients. This proposal requires EIP-2929 and EIP-2930. The original status is Stagnant, meaning discussion is no longer active and it has not been included in any fork.