EIP-7999 Unified multidimensional fee market
No call decision · Fees & gas · EIP status Draft · created 2025-08-04
Instead of transactions setting a separate fee cap per resource, this changes it so that only a single max_fee budget is specified, unifies execution gas and blob fee markets into one mechanism, and splits out calldata as the first independent resource.
Why it is needed
Ethereum currently uses two separate fee mechanisms, one for execution gas (EIP-1559) and one for blob gas (EIP-4844). As multidimensional markets that price resources such as calldata or state separately are introduced going forward, the current approach would require users to set a separate fee cap for each resource. In that case, even a brief spike in the price of just one resource could exclude a transaction that, overall, was willing to pay enough. This causes a loss where a transaction that the user, the block proposer, and the protocol would all be willing to process gets blocked purely because of design rigidity. Also, users typically do not think in terms of per-resource unit prices, but rather in terms of "how much ETH am I willing to pay for this transaction." This EIP takes advantage of the fact that fee budgets are fundamentally fungible across resources, automatically allocating a single ETH budget across whichever resources incur costs. Since there is no longer a need to keep separate buffers against per-resource price swings, capital can be used more efficiently.
What changes
Today
- Execution gas and blob gas move under two separate fee mechanisms, EIP-1559 and EIP-4844, respectively
- Users set max_fee_per_gas and max_fee_per_blob_gas separately for each resource
- Even if only one resource's base fee spikes, a transaction with a sufficient overall budget may fail to be included
- Calldata is accounted for within execution gas and is subject to the EIP-7623 floor price
After EIP-7999
- The fee markets for all resources are unified into a single EIP-4844-style mechanism using the same update constant
- Transactions set only a single max_fee budget, and the protocol automatically allocates it across per-resource costs
- As long as the budget exceeds the total cost, the transaction can be included, removing the need for per-resource price-swing buffers
- Calldata becomes an independent resource with its own base fee, and the EIP-7623 floor price is repealed
Who is affected
- Users: Fees become easier to understand since they are set as a single total ETH amount rather than per-resource unit prices, and calldata costs come down.
- Wallet & app developers: A new estimation routine is needed that looks up the per-resource base fee vector and proposes a max_fee combining the expected total cost with a buffer.
- Client teams: Requires implementing a new transaction type, vectorized header fields (gas_limits, gas_used, excess_gas), and a new opcode, CALLDATABASEFEE.
- L2 (rollups): Calldata throughput increases and its price comes down, but since the reserve price keeps calldata's per-byte price one third higher than blobs, it does not become cheaper than blobs.
In depth
New transaction type and single max_fee
Introduces a new EIP-2718-style transaction type, MULTIDIM_TX_TYPE (value TBD). The payload is [chain_id, nonce, gas_limit, to, value, data, access_list, blob_versioned_hashes, max_fee, max_priority_fee_per_gas, y_parity, r, s]. max_fee is a single integer from 0 to 2**128-1, and max_priority_fee_per_gas is an integer list whose length is either 1 or equal to the number of resources (3 initially). In other words, the tip can be set as a single value, or advanced users can specify it per resource. gas_limit is initially specified only for the main EVM gas, with blob and calldata limits inferred from the transaction contents. The intrinsic cost inherits from EIP-4844, except that the calldata gas cost (16 per nonzero byte, 4 per zero byte) is removed.
Block processing and fee settlement
At the start of a block, the gas_used_so_far vector is initialized to [0, 0, 0], and the per-resource base fees are obtained from the parent header. For each transaction, it checks whether max_base, computed by multiplying the base fee vector by the gas limit vector and summing, is no more than max_fee, and whether adding the transaction's limits to the cumulative usage would exceed the block's per-resource limits. First, the amount of max_base plus the priority fee is deducted; after execution, the base fee for the gas actually consumed is burned, the priority fee is sent to the coinbase, and the remainder is refunded. Blob and calldata gas consumption are treated as equal to their limits. Existing transactions remain usable by converting max_fee_per_gas times the gas limit (plus the blob share for blob transactions) into max_fee, and by subtracting calldata gas from the old gas_limit to obtain the execution gas share. At the end of the block, the header's gas_used vector must match the cumulative total.
Header vectorization and gas normalization
This removes gas_limit, gas_used, base_fee_per_gas, blob_gas_used, and excess_blob_gas from the block header and adds gas_limits, gas_used, and excess_gas in the form [int, int, int]. Index 0 is EVM gas, 1 is blob, and 2 is calldata. The EVM gas target is 1/2 of the limit (EVM_LIMIT_TARGET_RATIO = 2), the blob limit and target come from EIP-7840's blobSchedule, and the calldata limit is gas_limits[0] // CALLDATA_GAS_LIMIT_RATIO(4), with the target set to 1/4 of that limit (CALLDATA_LIMIT_TARGET_RATIO = 4). The excess gas delta for each resource is normalized by dividing by that resource's limit and scaling by GAS_NORMALIZATION_FACTOR (10**9), so all resources share a single BASE_FEE_UPDATE_FRACTION (4,245,093,508, approximately 10**9/(2·ln 1.125)), preserving the existing price volatility range even when limits change, so prices do not become unstable.
Separating calldata as its own resource
Calldata gas costs CALLDATA_GAS_PER_TOKEN(4) per token and TOKENS_PER_NONZERO_BYTE(4) tokens per nonzero byte, preserving the existing per-byte price, but EIP-7623's floor price is repealed. At a 60M execution gas baseline, a block would carry an average of 3.75M calldata gas (about 234kB), compared to roughly 150kB under the current ratio, so calldata usage can rise more than 50% while the price falls. The limit is 15M gas (about 938kB), smaller than the current worst-case block of 1.5MB under EIP-7623, reducing worst-case propagation burden. Since calldata is separated from execution gas, the combined gas limit effectively rises to 75M, but this has little impact on peak execution load. Unlike EIP-7623 and EIP-7976, which apply conditional per-transaction pricing, this is a block-level price, so there is no incentive for a secondary market seeking rebates.
Generalizing the reserve price (EIP-7918)
This generalizes EIP-7918's reserve price logic so it can be applied to any resource. If a resource's base fee multiplied by GAS_RESERVE_FACTOR is lower than the base fee of the reference resource (GAS_RESERVE_INDEX), that resource's excess gas can only rise with usage and cannot fall. The constants are GAS_RESERVE_FACTOR = [0, 16, 12] and GAS_RESERVE_INDEX = [0, 0, 1]: blob gas uses a factor of 16 relative to EVM gas's base fee (as in the existing EIP-7918), and calldata uses a factor of 12 relative to blob gas's base fee. Since calldata costs 16 gas per byte and blobs cost 1 gas per byte, this condition prevents calldata's per-byte price from falling below about 1.33x (16/12) of the blob price. This prevents calldata from becoming cheaper than blobs and causing L2s to shift from blobs to calldata, and also prevents the fee update mechanism from dropping into a low-price regime where it stops functioning properly.
The CALLDATABASEFEE instruction
This adds the CALLDATABASEFEE (0x4b) instruction, which returns the current block's calldata base fee. It takes 0 inputs, returns 1 output, and costs 2 gas, following the same principle EIP-7516 established for the blob base fee. Since calldata becomes a separate resource with its own base fee, this gives contracts a way to read that price directly on-chain. The Motivation section explains that separating calldata is a way to speed up worst-case payload propagation and expand available EVM gas without harming gas introspection.
Censorship resistance and EIP-7805
This specifies the interaction with EIP-7805, an inclusion list (IL) proposal. Resources are divided into three types: conditional resources must include an IL transaction if capacity remains, unconditional resources cannot cite their own capacity shortage as grounds for exclusion, and deconditional resources can be excluded at any time. EVM gas is conditional, blob gas is deconditional, and calldata is unconditional. If an IL transaction using calldata is excluded even though conditional resource capacity is sufficient, INVALID_INCLUSION_LIST must be raised. Per-resource limits could make it easier for censorship to occur by having a builder fill only one cheap resource to make a block appear full. However, since each of the 16 ILs per slot is capped at 8KiB, the total IL transaction volume is at most 131kB, and subtracting that from the 938kB calldata limit leaves 807kB, which is explained as sufficient for a builder's MEV activity, so this EIP does not harm censorship resistance.
Expansion paths and current status
Calldata is only the first step toward a multidimensional market, and the EIP also lays out paths for separating other resources such as state and for making EVM gas itself multidimensional. Candidate paths include abandoning gas introspection entirely (as with EOF's EXTCALL), keeping gas fungible across resources, a hybrid model that lets implementations choose between an aggregated single EVM gas limit and per-resource limits, and combining this with multidimensional gas metering. However, extending to other resources requires further multidimensional gas repricing work that is not yet finished, and transitioning across several hard forks is considered the best approach. This EIP is in Draft status, created on August 4, 2025, so the specification and constants (such as the MULTIDIM_TX_TYPE value) may still change, and no core developer call decision has been made yet on which fork it will go into.