EIP-8075 Limiting State Growth with Adaptive State Costs (Adaptive state cost to cap growth & scale L1)

No call decision · Fees & gas · EIP status Draft · created 2025-10-02

Tracks the state bytes created and deleted in each block, and adjusts the gas cost of state creation every block using an EIP-4844-style fee market, capping state growth at a target of 250 MiB per day. State gas is split off from the regular gas limit to help L1 scaling.

Why it is needed

Ethereum is currently focused on L1 scaling, and the block gas limit is expected to rise quickly in the near future. But if the gas cost of state creation, such as creating a new account or storage slot, stays fixed, then as the gas limit rises, the data nodes must store grows proportionally, which can degrade client performance. EIP-8037 unifies state creation costs on a per-byte basis and raises them by 3x to 9.5x, but how much users will respond to the higher prices (price elasticity) is unknown. According to the source's analysis, if usage patterns stay the same, state could end up accounting for 78.5% of total gas, and even if state usage is cut in half, it could still settle at 64.7%. If state gas eats into the block limit, it crowds out other resources like computation and blocks scaling. So a mechanism is needed that automatically adjusts price based on state usage and splits state gas out of the regular gas limit.

What changes

Today

After EIP-8075

Who is affected

In depth

Parameters: a target of 36,400 bytes per block

TARGET_STATE_BYTES_PER_BLOCK is 36_400, and MAX_STATE_BYTES_PER_BLOCK is twice that. MIN_STATE_GAS_PER_BYTE is 380, which is the EIP-8037 cost converted to a floor based on a 60M gas limit. STATE_GAS_UPDATE_FRACTION is 36_418_000, derived by rounding (MAX_STATE_BYTES_PER_BLOCK - TARGET_STATE_BYTES_PER_BLOCK) / ln(1.001) to the nearest thousand. This value ensures that even when a block uses the maximum, state_gas_per_byte rises by at most 0.1% per block. Per-operation byte counts follow EIP-8037: CREATE_BYTES 112, CODE_DEPOSIT_BYTES 1, NEW_ACCOUNT_BYTES 112, STORAGE_SET_BYTES 32, PER_EMPTY_ACCOUNT_BYTES 112, PER_AUTH_BASE_BYTES 23.

Header Extension and Field Renaming

Three new 64-bit unsigned integer fields are added to the block header. state_bytes_created is the state bytes created in that block, state_bytes_cleared is the state bytes deleted, and excess_state_bytes is the cumulative state bytes over target accumulated up to before the block. Blocks over target raise this value, and blocks under target lower it, never going below 0. The new field order is [..., TBD, state_bytes_created, state_bytes_cleared, excess_state_bytes]. In addition, the existing gas_used field is renamed to regular_gas_used, recording only regular gas with state creation gas excluded.

Computing and Updating the State Gas Price

state_gas_per_byte is computed the same way as in EIP-4844, via fake_exponential(MIN_STATE_GAS_PER_BYTE, excess_state_bytes, STATE_GAS_UPDATE_FRACTION). This is the value EIP-8037 called cost_per_state_byte. The excess_state_bytes update, in calc_excess_state_bytes, compares the parent block's excess plus state_bytes_created against the target plus state_bytes_cleared, carries forward the difference, and floors it at 0 if negative. Accounting for deleted bytes as well is what differs from 4844. Each block, the gas cost of every state operation is recomputed as byte count times unit price. For example, GAS_NEW_ACCOUNT = state_gas_per_byte × NEW_ACCOUNT_BYTES.

Separate Gas Accounting and Base Fee Update

During execution, the protocol tracks regular_gas and state_gas separately. A transaction's gas_used is the sum of the two with refunds applied, while only regular_gas_used, without refunds, is counted against the block limit to comply with EIP-7778. The base fee is updated using the sum of regular gas and normalized state gas. normalized_state_gas_used = parent.gas_limit × (state_bytes_created - state_bytes_cleared) // MAX_STATE_BYTES_PER_BLOCK, calibrated so that when the net increase in state bytes is at its maximum, it equals the block gas limit in size. The range of change remains capped at ±12.5% as before. In other words, state_gas_per_byte is a separate control that prices state relative to other resources, while the base fee still applies across all resources.

Block Validation Rules

Block validation first checks that excess_state_bytes matches calc_excess_state_bytes(parent header), then computes state_gas_per_byte to update the state operation gas price. For each transaction, it accumulates gas_used, regular_gas_used, and the state_bytes (created, cleared) vectors returned by execution. Refunds work as they do today, and only regular_gas_used (without refunds) is added to the block gas counter. Finally it verifies that state_bytes_created is at most MAX_STATE_BYTES_PER_BLOCK + state_bytes_cleared, and that the accumulated created/cleared bytes match the header values. This imposes a per block cap on net state growth.

Analysis of the limits of the fixed pricing approach (EIP-8037)

EIP-8037 charges a fixed price of 1900 gas per byte, but because state gas is included in the regular block limit it can block scaling. According to the source's calculations, if the current pattern (30% of gas spent on state at a 60M limit, 102 GiB per year, 286 MiB per day) continues while the limit is raised 5x to 300M and the state cost is raised 8.5x, then at equilibrium 78.5% of all gas is spent on state. Real scaling is limited to only 1.54x, and state growth rises to 157 GiB per year (440 MiB per day). Even if users cut their state purchases in half, 64.7% is still spent on state and real scaling is only 2.52x. By contrast, removing state from the regular gas limit as this proposal does allows a 7.14x increase measured against non state operations.

Alternative designs considered

The source compares three alternatives. First, a multidimensional sub fee market would have transactions carry separate regular_gas_limit and state_byte_limit fields, computing gas_limit at execution time; this removes the risk of failure from price fluctuation but requires changing the transaction format. This proposal could be adopted first and migrated to that design later. Second, EIP-8011's multidimensional gas metering updates the base fee using the max of per resource consumption, but without a dedicated state price, control over state growth is weaker. Third, EIP-7999's aggregate gas approach keeps the format unchanged while separating out fee_per_state_gas, but if max_fee_per_gas is set too tightly, builders cannot know in advance of execution whether the fee will be satisfied. This EIP also combines well with applying EIP-8011 metering to the remaining resources only, in which case EIP-8037's special handling of code_deposit_gas also becomes unnecessary.

Wallet compatibility and proposal status

Because the price changes every block, a transaction with a very tightly set gas limit can fail if state_gas_per_byte moves between submission and execution. Wallets should query excess_state_bytes to compute the unit price, then set the limit as gas_limit = regular_gas_limit + state_bytes x state_gas_per_byte x m, multiplying by a margin factor m. The rate of change itself is tuned via STATE_GAS_UPDATE_FRACTION to a level that mitigates UX concerns. This EIP is currently in Draft status, so the constants and detailed design in the specification are still subject to change, and some header field ordering remains TBD. There is as yet no core developer call decision on whether to include it in a fork.

Original EIP · ← EIPs