EIP-8011 Multidimensional gas metering
No call decision · Fees & gas · EIP status Draft · created 2025-08-22
Changes how gas spent by a transaction is recorded, splitting it across six distinct resource dimensions such as compute and storage, and determines whether a block is full by looking only at the single most-used resource. Transaction fee calculation and the user experience remain unchanged.
Why it is needed
Today, Ethereum lumps together entirely different kinds of resource consumption, CPU computation, disk reads, data size, memory, and state storage, into a single number called gas. Because the block limit is also tied to this sum, packing a compute-heavy transaction together with a storage-heavy one can cause a block to be treated as full even though no single resource has actually hit its limit. This reduces the number of transactions a block can hold. Conversely, there is no separate mechanism to control a block that overloads the network by concentrating heavily on one specific resource. This proposal leaves transaction pricing unchanged while separating block-level metering by resource, aiming to increase throughput and allow more precise control over excessive resource use.
What changes
Today
- All resource consumption is counted as a single gas total, and the block limit also applies to this total
- Even when transactions using different resources are mixed into a block, it is calculated as full based on the combined total
- The base fee is adjusted based on the block's overall gas usage
After EIP-8011
- Every EVM operation is assigned a six-dimensional cost vector by resource, and the block tallies usage separately for each resource
- Whether a block is full is judged solely by the single most-used bottleneck resource (max_gas_metered)
- The base fee is adjusted based on the usage of the bottleneck resource
- From a transaction's perspective, there is still just one gas limit and one gas usage figure, as before
Who is affected
- Users and wallets: There is no perceptible change because the way gas limits are set and fees are calculated stays the same.
- Client teams: Implementing this requires per-operation cost vectors, per-resource gas tallying, new header fields, and block validity rules, and it needs a hard fork.
- Block builders: Filling a block optimally becomes more complex because multiple resource axes must be considered together. A simple approach of filling until one resource saturates is still generally effective, however.
- Validators and node operators: Per-resource limits allow more precise control over the burden a worst-case block places on any specific resource.
In depth
The six-dimensional cost vector
Every EVM operation is assigned gas_cost_vector = (compute_cost, access_cost, size_cost, memory_cost, state_cost, history_cost). Pure compute instructions (compute_ops) place the existing gas cost entirely in the compute dimension, as (gas_cost, 0, 0, 0, 0, 0). Compute-and-memory instructions (compute_mem_ops) place the memory expansion cost (per calculate_gas_extend_memory) in memory_cost, and the existing gas cost minus the memory expansion cost in compute_cost. The vector allocation for state operations (state_ops), LOG operations (log_ops), and a transaction's intrinsic cost (calculate_intrinsic_cost) is TBD, pending benchmark results.
Transaction-level accounting stays the same
After the i-th operation executes, the remaining gas decreases, and gas_used increases, by the sum of the cost vector's components, exactly as before. A new addition is gas_used_vector, a per-resource running total that is updated alongside it. A transaction still has just a single one-dimensional gas_limit, the gas-exceeded condition remains gas_used <= gas_limit, and fees are still calculated from gas_used. The only change at the transaction level is that the execute_transaction function now also returns gas_used_vector along with gas_used.
Header extension: max_gas_metered
A new 64-bit unsigned integer field, max_gas_metered, is added to the block header. Its value is the maximum among the per-resource sums of gas_used_vector across every transaction in the block, that is, the total gas usage of the bottleneck resource. The header field order becomes [..., parent_beacon_block_root, requests_hash, max_gas_metered]. Block validity checking changes from block.gas_used to block.max_gas_metered <= block.gas_limit, and the base fee update also becomes based on the bottleneck resource, via gas_used_delta = parent.max_gas_metered - parent.gas_target. The source states that this change is compatible with transaction variants such as EIP-1559, EIP-4844, and EIP-7999.
Why split resources this way
Because Ethereum must finish block execution, verification, and attestation propagation within a single slot, time is the fundamental resource. The proposal divides resources into block execution time (compute, state access), block transmission time (block size), short-term memory (RAM), and long-term storage (state growth, history growth). Blobs, which are already priced independently, are excluded. Empirical measurements over blocks 22,000,000 to 22,005,000 showed state growth accounting for 30.2% of total gas, compute 26.8%, state access 21.9%, history growth 9.9%, and data 6.9%.
Security considerations
Metering resources independently makes worst-case blocks that concentrate on a single resource possible, so each operation's cost vector must be set carefully through benchmarking. Because state and history growth are resources constrained over the long term rather than per block, rising total gas usage may require raising the cost of the relevant operations. There is room for builders to manipulate the base fee by adjusting max_gas_metered through transaction selection, but the incentive to maximize fee revenue limits this. In a FOCIL (EIP-7805) setting, the cost of censorship by filling a block with dummy transactions that consume only a single resource could fall, but since the base fee is the same across all resources and at least one resource must be filled to its limit, the source assesses the resulting reduction in censorship resistance as relatively mild.
Status is Draft and key figures are undetermined
This proposal is in Draft status, so its contents may change. The vector allocation for state operations, LOG operations, and transaction intrinsic cost are all TBD pending benchmarks, and adoption requires a hard fork. The source explains that this metering change is the foundation for multidimensional pricing schemes such as EIP-7999. The provided core developer call records contain no fork-inclusion decision for this EIP.