EIP-8296 Fixed-Cutoff State Tiering
No call decision · Fees & gas · EIP status Draft · created 2026-06-10
A single reference block (CUTOFF_BLOCK) is set, and changing "inactive" state that was last written before it incurs an extra charge on top of normal gas. Reads and new state creation are unaffected.
Why it is needed
Ethereum's state (account balances, contract storage values, etc.) keeps growing, and a large portion of it is cold state that is written once and never touched again. Yet every node still has to keep this cold state in the working data it handles every block, and the cost of fixing long-neglected state is identical to the cost of fixing state that was just written. This proposal splits state into active and inactive just once, using a single reference block set by social consensus. Inactive state still remains in the state trie, so no complex mechanism for deleting and reviving state (state expiry) is needed. Because the inactive set is fixed at activation time, once it is built into a file it never changes, and if clients use the same file format, any node can fetch that file from any mirror and verify it. This is the same picture as the current approach of distributing block history split into era files.
What changes
Today
- The gas cost of changing state is the same whether it was long neglected or just written
- Nodes keep even rarely used cold state together in the hot database written every block
- There is no common way to split off cold state and exchange it between clients
After EIP-8296
- Changing inactive state that was last written before CUTOFF_BLOCK incurs extra gas
- Because the inactive set is fixed, nodes can move it into a file and shrink the hot database
- If clients converge on the same file format, the inactive set can be fetched from any mirror and verified against the state root
Who is affected
- Users: If you only deal with recently written state as usual, there is no change in cost. Extra gas is incurred only the first time you rewrite a long-dormant account or contract storage value.
- Wallets and RPC providers: eth_estimateGas needs to be updated so that an extra charge is captured when the write target is inactive state.
- Client teams: Implementing the tier-determination and charging logic, and converging on a shared file format (recommended) to hold the inactive set, can shrink the hot database.
- Old contracts and their users: Transactions that move the state of a contract that stopped before the cutoff become more expensive than now.
In depth
Tier determination resolved by a single comparison
It reads the last_written_block recorded by EIP-8188 for each account and storage slot, and classifies it as inactive if that value is less than CUTOFF_BLOCK, or active otherwise. That one comparison is the entire determination. There are three parameters: CUTOFF_BLOCK, INACTIVE_ACCOUNT_WRITE_SURCHARGE, and INACTIVE_STORAGE_WRITE_SURCHARGE, and all of their values are TBD. The two surcharges MUST be greater than zero, and they are added on top of the operation's normal gas rather than replacing it. This EIP does not define the encoding or update rules of last_written_block; it only reads it. Ownership of that belongs to EIP-8188.
Operations and leaves that incur the extra charge
The extra charge is applied for every inactive leaf an operation writes. An SSTORE that changes an existing slot's value pays both the slot's share and the account leaf's share that changes along with it via the storageRoot recalculation cascade. An SSTORE that creates a new slot (from 0 to a nonzero value) and an SSTORE that clears a slot (to 0) pay only the account's share. CALL and CALLCODE that transfer value are charged separately for the sending and receiving accounts if each is inactive, and a newly created recipient account is exempt. For simple-transfer transactions and the authority account share of EIP-7702 delegation, the charge is folded into intrinsic gas and evaluated at transaction validation. Nonce increment is charged to that account; CREATE and CREATE2 are charged only to the creator account, and the new contract account, its code, and the slots set by the constructor are all exempt. SELFDESTRUCT is charged for each side whose balance changes, if that side is inactive. Reads such as SLOAD, BALANCE, the EXT* family, and value-less calls are unaffected. The tier is determined by the last_written_block at the time the operation starts. Since writing makes it active, a single leaf is charged at most once per block.
The extra charge is regular-gas
The extra charge is regular-gas, not state-gas, because reviving inactive state is an input/output (I/O) operation rather than newly growing state. It is therefore subject to EIP-7825's TX_MAX_GAS_LIMIT like any other regular-gas, and is tallied on the block's regular-gas side under EIP-8037's two-dimensional accounting. It is not refunded, and remains spent even if the call frame later reverts or halts on an exception. This is consistent with EIP-8037, which rolls back state-gas on revert but does not roll back regular-gas. However, when a revert occurs, the last_written_block update from EIP-8188 is also rolled back along with that frame's state, so the leaf remains inactive, and rewriting it later incurs the extra charge again.
State creation is exempt, but the level is matched
Creating state, such as a new account, a new storage slot, or newly deployed code, is not classified as inactive and incurs no extra charge. The creation price is set by EIP-8037. The exemption applies only to the leaf being created. If an SSTORE creates a new slot on a long-dormant contract, the slot itself is exempt as a creation, but because the storageRoot cascade revives the existing account leaf, the account's share of the extra charge still applies. It is also recommended (SHOULD) that the extra-charge level be set so that fixing existing inactive state is not cheaper, in terms of block resources, than creating similar new state. Otherwise, reviving old state would become a cheaper way to use the same node resources.
A different axis from EIP-2929 warm/cold
Active/inactive is a write tier determined by comparing last_written_block against CUTOFF_BLOCK, and it only affects write cost. EIP-2929's warm/cold is a concept about whether this is the first access within a transaction, and it continues to apply to reads as it does now. For a write, the tier is determined first, and then the corresponding write cost is applied. The two distinctions do not overlap and operate independently.
Shared file format for the inactive set (recommended)
As a RECOMMENDED, not a consensus rule, this proposes that clients converge on a single shared file format holding the inactive set as of CUTOFF_BLOCK. Since the cutoff is fixed, the set is fixed too, so a write-once, immutable file suffices. Because the contents are a subset of that block's state, each entry's last_written_block and value must be provable against the state root, and clients MUST be able to fetch the file without trusting whoever produced it. An index for looking up a specific account or slot without scanning the whole file is also recommended. If the format is shared, the set can be exchanged over ordinary channels like HTTP or BitTorrent, the same way block history is distributed as era files, making it practically feasible for nodes to split the cold set off from the hot database. Byte-level encoding is left as separate work.
Weaknesses of a fixed cutoff and attack cost
The key weakness is that the active set only grows in one direction between forks. Once an inactive item is written, it stays active, and there is no mechanism for it to revert to inactive on its own. An attacker could pay the extra charge to revive the inactive set in bulk and inflate the hot working set, but the source material explains that two things limit this: each item requires paying the extra charge, so it is not cheap, and the block gas limit caps the rate; and if a later fork moves CUTOFF_BLOCK forward, state that cooled again in the meantime (including state the attacker revived and then abandoned) gets reclassified as inactive. Also, since this classification is write-based only, a slot that is read every block but never rewritten is still inactive. If a client moves inactive state to slower storage without separately accounting for read frequency, that can become a denial-of-service attack vector. The choice of CUTOFF_BLOCK itself is also a governance question: too close and it over-penalizes ordinary activity, too far and its effect is blunted, so it should be set based on the distribution of write ages at the time of the fork.
Draft status and activation conditions
This EIP is in Draft status, so its contents may still change, and CUTOFF_BLOCK and the two additional fee values are all to-be-determined (TBD). Because this is a backward-incompatible gas rebalancing, it can only be activated via a scheduled network upgrade. It depends on EIP-8188, so it must be activated at the same fork or later, and CUTOFF_BLOCK must be set above the EIP-8188 activation block so that the last_written_block comparison remains meaningful. Wallets and RPC providers must update eth_estimateGas so that transactions touching inactive state reflect the additional fee. There is no core developer call decision yet on including this EIP in a specific fork.