EIP-8131: Unified Transaction Content Floor

Flat 64 gas per content byte at the floor, covering all user-controlled transaction fields and capping worst-case block size.


Metadata
Status: DraftStandards Track: CoreCreated: 2025-01-21
Authors
Toni Wahrstätter (@nerolation)

Abstract


Charge every user-controlled byte in a transaction (calldata, access-list entries, EIP-7702 auths, EIP-4844 blob hashes) at a flat 64 gas at the floor. One floor rule replaces the floor terms of EIP-7623/EIP-7976 and EIP-7981 and closes the auth and blob hash floor gaps. Worst-case user-controlled transaction content per block is bounded by block_gas_limit / 64 (0.89 MiB at 60M gas). Together with EIP-8279, which prices the bytes execution adds to the block access list, this bounds the payload bytes of the whole block, up to a small fixed overhead per transaction. Against Glamsterdam, 0.66% of mainnet transactions pay more, all of them blob carriers and EIP-7702 transactions.

Motivation


Every node must be able to handle the largest block an attacker can build, not the average one. Lowering that worst case buys headroom, which can either be spent on throughput by raising the gas limit or kept as a buffer. Left unspent, it is a direct gain in robustness. EIP-7623 introduced a floor cost on calldata bytes to cap worst-case block size. EIP-7976 raised that floor to a uniform 64 gas per calldata byte, zero and non-zero alike (by treating every byte as 4 floor tokens at 16 gas each). EIP-7981 extended the same 64 gas/B rate to access-list bytes via a flat data-cost surcharge of 1,280 gas per address and 2,048 gas per storage key. The principle is consistent across both: every user-controlled content byte priced at 64 gas at the floor.

EIP-7702 authorization tuples (up to 133 B each) and EIP-4844 blob versioned hashes (32 B each) were added without matching floor terms and still pay nothing at the floor.

FieldFloor rateSource
Calldata byte (zero or non-zero)64 gasEIP-7976
Access-list address (20 B)1,280 gasEIP-7981
Access-list storage key (32 B)2,048 gasEIP-7981
EIP-7702 authorization tuple (up to 133 B)0uncovered
EIP-4844 blob versioned hash (32 B)0uncovered

Each per-component extension has needed its own EIP and its own constants. This EIP folds EIP-7976 and EIP-7981 into a single per-byte rule covering every user-controlled tx-content field, and pulls authorization tuples and blob versioned hashes into the same rule. The result is one formula that auto-prices any future variable-length tx field at the same rate, and a worst-case content bound provable from arithmetic.

Specification


The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174.

Constants

FLOOR_GAS_PER_BYTE             = 64    # per-byte floor rate established by EIP-7976 (calldata) and EIP-7981 (access lists)
ACCESS_LIST_ADDRESS_BYTES      = 20
ACCESS_LIST_STORAGE_KEY_BYTES  = 32
AUTHORIZATION_BYTES            = 133   # EIP-7702 authorization tuple, largest valid RLP encoding
BLOB_VERSIONED_HASH_BYTES      = 32

Transaction floor

Let base_gas be the transaction's decomposed intrinsic base as defined by EIP-2780: TX_BASE_COST (12,000), plus COLD_ACCOUNT_ACCESS if tx.to is an account other than the sender, plus TX_VALUE_COST for a non-zero value transfer to another account, or plus CREATE_ACCESS for a contract creation. Per-authorization and initcode charges are not part of base_gas. This is the same base the EIP-7623 floor sits on once EIP-2780 is active.

tx_floor = base_gas + FLOOR_GAS_PER_BYTE * (
      len(tx.data)
    + ACCESS_LIST_ADDRESS_BYTES      * num_access_list_addresses
    + ACCESS_LIST_STORAGE_KEY_BYTES  * num_access_list_storage_keys
    + AUTHORIZATION_BYTES            * num_authorizations
    + BLOB_VERSIONED_HASH_BYTES      * num_blob_versioned_hashes
)

A field absent from a given transaction type contributes zero (the corresponding count is zero).

tx_floor replaces the EIP-7976 calldata floor and the EIP-7981 access-list floor term.

Intrinsic gas

Intrinsic gas is unchanged. It keeps the EIP-7981 access_list_data_cost of 64 gas per access-list byte, alongside the EIP-2930 per-entry charges and the EIP-2028 calldata charges.

Charging

require tx.gas >= max(intrinsic, tx_floor)
require tx_floor <= TX_MAX_GAS_LIMIT
tx.gasUsed   =   max(execution_gas_used, tx_floor)

execution_gas_used is the gas the transaction uses before the floor is applied: intrinsic gas plus execution after refunds, including EIP-8037 state gas. TX_MAX_GAS_LIMIT is defined in EIP-7825. The max(intrinsic, floor) shape of EIP-7623 is preserved.

Rationale


One per-byte rate

Pricing every content byte at the same FLOOR_GAS_PER_BYTE already used by EIP-7976 for calldata and by EIP-7981 for access-list bytes makes the worst case invariant to the attacker's choice of field or byte value: calldata, access-list entries, authorization tuples, and blob versioned hashes all yield 1/64 bytes per gas at the floor. The optimum collapses to B = block_gas_limit / 64. The bound holds independent of the network compressor, attacker strategy, or content composition.

Content-only, not full RLP

Charging every encoded byte (envelope and signature included) would make legacy transactions strictly cheaper than equivalent EIP-1559 transactions for the same payload, because legacy has a smaller envelope. Content-only is type-symmetric: two transactions with identical content pay identical floor regardless of tx type.

base_gas covers envelope

Envelope, signature, and type prefix take about 110 to 120 bytes for a typical transaction and stay below about 165 bytes even with every scalar field inflated to what the ETH supply allows, for every transaction type defined to date. At FLOOR_GAS_PER_BYTE that is at most about 10,600 gas, below the smallest possible base_gas (TX_BASE_COST = 12,000, a self-transfer). Charging the envelope explicitly would add about 7,000 gas to every bare ETH transfer; treating base_gas as covering it avoids that regression.

Access-list surcharge kept in intrinsic gas

EIP-7981 adds its access-list data cost to both sides of the max. With access-list bytes inside tx_floor, the floor side no longer needs it, but the intrinsic side still matters. An access-list storage key that execution later reads puts 32 bytes into the transaction and another 32 bytes into the EIP-7928 block access list, which this EIP does not price. Without the surcharge, such a key costs about 2,100 gas (the EIP-2930 key charge plus a warm SLOAD) for 64 bytes, so a 60M-gas block of them would hold about 1.74 MiB, more than any construction allows under Glamsterdam (1.546 MiB). EIP-8279 meters block access list bytes and keeps the surcharge, which also limits how far RLP framing can push encoded block size above the payload bound.

Standard intrinsic unchanged

The standard intrinsic per-byte rate (EIP-2028: 4 gas per zero, 16 gas per non-zero) is preserved. It prices EVM and state work per byte and is unrelated to the bandwidth-bound floor. Raising it would increase intrinsic cost for every transaction with non-zero data without improving the bandwidth-defense properties this EIP targets.

Per-auth term is a constant

AUTHORIZATION_BYTES = 133 is the largest RLP encoding of an EIP-7702 authorization tuple a valid transaction can carry: 2 B list header, 33 B chain_id, 21 B address, 9 B nonce, 2 B y_parity, and 33 B each for r and s. EIP-7702 bounds these fields only by their integer widths (chain_id < 2**256, y_parity < 2**8) at transaction validity. An authorization with any other chain ID or an invalid signature is skipped during processing, but the transaction stays valid and its bytes stay in the block, so the constant must cover them. A smaller constant (for example 108, which assumes an 8-byte chain_id and a 1-byte y_parity) would let a block of such authorizations exceed the block-size bound by about 9%, since each one is charged the 7,816-gas intrinsic per-authorization cost rather than its bytes at the floor rate.

Using a constant rather than len(rlp_encode(auth)) keeps the floor computable from counts alone. A typical mainnet authorization (chain ID 1, nonce below 128) encodes to 92 bytes and over-pays by 41 × 64 = 2,624 gas at the floor. The name differs from AUTH_TUPLE_BYTES = 101 in the execution specifications, the per-authorization byte count EIP-8037 uses to price authorization calldata in intrinsic gas.

Backwards Compatibility


Hard fork.

This EIP lands on top of EIP-2780, EIP-7976 and EIP-7981. Impact on every mainnet transaction over 90 days (2026-08-22 to 2026-11-19, 168,284,788 transactions), with execution gas held at today's level (full report):

TypeShareAvg content (B)Bind rate todayBind rate GlamsterdamBind rate under EIP-8131Pay more vs Glamsterdam
0 Legacy12.89%2230.14%1.49%1.49%0.00%
1 EIP-29300.07%4410.09%10.35%10.35%0.00%
2 EIP-155984.81%5351.88%4.75%4.75%0.00%
3 EIP-48440.80%8390.05%0.08%55.80%55.80%
4 EIP-77021.43%4,4560.04%13.16%15.32%15.32%

The "bind rate" is the share of transactions whose tx.gasUsed is set by tx_floor rather than by intrinsic gas plus execution. Against Glamsterdam, 0.66% of transactions pay more, adding 0.09% to total gas, and no transaction pays less; the aggregate bind rate rises from 4.42% to 4.89%. Against today's mainnet, 4.93% of transactions pay more (+2.30% gas), 96% of it from the EIP-7976 calldata rate that Glamsterdam already ships.

The increase falls on the two fields that were uncovered:

  • Type 3 (blob carriers): blob carriers execute almost nothing, so 2,048 floor gas per blob versioned hash sets their gas used; about 6,100 gas per affected transaction, paid almost entirely by L2 batchers.
  • Type 4 (SetCode): 8,512 floor gas per authorization, on transactions whose calldata is often already floor-bound under EIP-7976. One sender accounts for 69% of all extra gas.
  • Legacy, EIP-2930, EIP-1559: unchanged; their content is already priced at 64 gas per byte in the Glamsterdam floor, and intrinsic gas is unchanged.

Senders that set tight, fixed gas limits must account for the new terms: 26% of blob transactions in the window carried a gas limit below their EIP-8131 floor.

When does the floor bite? For calldata-only transactions:

tx_floor > gas_used  ⇔  calldata_bytes  >  (gas_used − base_gas) / FLOOR_GAS_PER_BYTE

A typical token transfer (68 B calldata, no value, ~50 k gas) has base_gas = 15,000 and tx_floor = 19,352, well under gas_used. A 50 k-gas call needs more than 546 B of calldata before the floor bites.

Wallets and eth_estimateGas MUST compute the new floor.

Test Cases


base_gas follows EIP-2780: 21,000 for a value transfer to another account, 15,000 for a call to another account without value, 12,000 for a self-transfer.

Bare ETH transfer

tx.to = recipient, tx.value = 1 ether, tx.data = b"", no access list, no authorizations, no blob hashes.

  • tx_floor = base_gas = 21,000 gas. Unchanged.

Calldata-only transaction

Call to a contract with tx.value = 0 and 10,000 calldata bytes, no other variable-length content.

  • tx_floor = 15,000 + 64 × 10,000 = 655,000 gas. Identical across all transaction types carrying the same calldata.

Access-list entry: address with one storage key

Call to a contract with tx.value = 0, empty calldata, and one access-list address with one storage key.

  • tx_floor = 15,000 + 64 × (20 + 32) = 18,328 gas.

EIP-7702 with one authorization

Call to another account with tx.value = 0, empty calldata, one authorization.

  • tx_floor = 15,000 + 64 × 133 = 23,512 gas.

EIP-4844 with six blob versioned hashes

Call to a contract with tx.value = 0, empty calldata, six blob versioned hashes.

  • tx_floor = 15,000 + 64 × (6 × 32) = 27,288 gas.

Security Considerations


Block-size bound

Every content byte is paid at FLOOR_GAS_PER_BYTE through tx_floor = base_gas + FLOOR_GAS_PER_BYTE * content_bytes. Block gas accounting under EIP-8037 has an execution and a state dimension; the floor is charged in the execution dimension, so each transaction's block execution gas is at least tx_floor, and the block's total execution gas is at most block_gas_limit:

content_bytes_per_tx * FLOOR_GAS_PER_BYTE  ≤  tx_floor - base_gas  <  block_execution_gas_per_tx
sum(content_bytes)  <  sum(block_execution_gas_per_tx) / 64  ≤  block_gas_limit / 64

At a 60M gas limit, the bound is 60,000,000 / 64 = 937,500 bytes (0.89 MiB) of content per block. It is derived from arithmetic, requires no compression assumption, and survives a change of the network compressor.

The bound counts content payload bytes: calldata, 20 bytes per access-list address, 32 bytes per storage key, 133 bytes per authorization tuple, and 32 bytes per blob versioned hash. On top of that, each transaction carries an envelope, signature, and RLP framing of about 110 to 165 bytes, which its base_gas (at least 12,000 gas, or 187 bytes at the floor rate) covers, plus one framing byte per storage key or blob versioned hash and at least three per access-list address. A block of 5,000 empty self-transfers, the most transactions a 60M block can hold, carries 550 to 700 KB of envelopes, depending on field sizes, and no content.

Type symmetry

Two transactions carrying identical content pay identical floor regardless of transaction type.

Gas estimation

Wallets and eth_estimateGas MUST compute tx_floor alongside intrinsic gas. Without it, estimates for floor-bound transactions are too low and submissions will be rejected at validation.

Copyright


Copyright and related rights waived via CC0.