EIP-8131: Add Auth Data to EIP-7623 Floor

Add EIP-7702 authorization data to the EIP-7623 floor calculation

Abstract

This EIP includes EIP-7702 authorization data in the EIP-7623 floor calculation, preventing circumvention of floor pricing through authorization lists. This effectively reduces the worst-case block size by ~16% with minimal user impact (~0.001% of mainnet transactions affected).

Motivation

EIP-7702 authorization tuples are priced for execution (PER_EMPTY_ACCOUNT_COST = 25,000 gas per authorization) but do not contribute to the EIP-7623 floor calculation.

Under EIP-7976 floor pricing, this enables circumventing the floor by combining all-non-zero calldata with authorization data at a 25%/75% (calldata/auths) gas split.

Specification

The EIP-7623 floor calculation is modified to include authorization data:

tokens_in_calldata = zero_bytes_in_calldata + nonzero_bytes_in_calldata * 4

floor_gas = (
    TX_BASE_COST
    + TOTAL_COST_FLOOR_PER_TOKEN * tokens_in_calldata
    + FLOOR_COST_PER_AUTH * num_authorizations
)

The gas used calculation becomes:

tx.gasUsed = (
    21000
    +
    max(
        STANDARD_TOKEN_COST * tokens_in_calldata
        + execution_gas_used
        + isContractCreation * (32000 + INITCODE_WORD_COST * words(calldata))
        + access_list_cost
        + PER_EMPTY_ACCOUNT_COST * num_authorizations,
        TOTAL_COST_FLOOR_PER_TOKEN * tokens_in_calldata
        + FLOOR_COST_PER_AUTH * num_authorizations
    )
)

A transaction is invalid if its gas_limit is less than tx.gasUsed evaluated with execution_gas_used = 0.

Rationale

Flat Cost Per Authorization

Each authorization is charged a flat FLOOR_COST_PER_AUTH = 6464 gas toward the floor, derived from:

• 101 bytes per authorization tuple (as specified in EIP-7702)
• 4 tokens per byte (treating all bytes as non-zero)
• 16 gas per token (TOTAL_COST_FLOOR_PER_TOKEN)

This conservative approach avoids byte-level zero/non-zero accounting while ensuring authorization data is properly reflected in the floor calculation.

Worst-Case Reduction

At the floor under EIP-7976 every byte costs 64 gas regardless of value, so the optimal attacker uses all-non-zero calldata (incompressible under snappy) at the standard rate of 16 gas/byte and spends the remainder on auths. The break-even split is (64 − 16) / 64 = 75% on auths and 25% on calldata. At a 60M gas limit:

# pre-EIP-8131 worst case (auth bypass, all-non-zero cd):
(0.75 * 60_000_000 * 101 / 25_000 + 0.25 * 60_000_000 / 16) / 1024**2  ≈  1.067 MB

# post-EIP-8131 worst case (pure floor, all-non-zero cd):
60_000_000 / 64 / 1024**2                                              ≈  0.894 MB

# reduction: 1 − 0.894 / 1.067 ≈ 16%

Empirical analysis over the last 6 months (2025-11-08 to 2026-05-08) (impact report) shows that only 0.124% of type-4 transactions (0.001% of all mainnet) and 0.330% of type-4 senders would be affected by this EIP.

Floor-Only Modification

Authorization costs are added to the floor calculation only, not to intrinsic gas. This differs from EIP-7981 (access lists) because:

• Authorization execution cost (25,000 gas) far exceeds floor contribution (6,464 gas per auth)
• Floor-only modification is sufficient to prevent bypass

With this change:

• Authorization data contributes to the floor path
• High-execution transactions remain unaffected (execution exceeds floor)
• Data-heavy transactions cannot use authorizations to bypass floor pricing

Backwards Compatibility

This is a backwards incompatible gas repricing that requires a scheduled network upgrade.

Requires updates to gas estimation in wallets and nodes. Normal usage patterns remain largely unaffected since authorization execution cost typically dominates the floor contribution.

Test Cases

Case 1: Transaction with Authorizations Only

• Calldata: 0 bytes
• Authorizations: 10

Old floor: 21,000 gas New floor: 21,000 + 10 × 6,464 = 85,640 gas Intrinsic: 21,000 + 10 × 25,000 = 271,000 gas Result: Pay intrinsic (271,000) — execution dominates, EIP-8131 has no effect

Case 2: Bypass Attempt (Now Blocked)

• Calldata: 100,000 non-zero bytes
• Authorizations: 225

Old floor: 21,000 + 100,000 × 64 = 6,421,000 gas New floor: 21,000 + 100,000 × 64 + 225 × 6,464 = 7,875,400 gas Intrinsic: 21,000 + 100,000 × 16 + 225 × 25,000 = 7,246,000 gas Pre-EIP-8131: max(7,246,000, 6,421,000) = 7,246,000 (intrinsic wins, floor bypassed) Post-EIP-8131: max(7,246,000, 7,875,400) = 7,875,400 (floor wins, bypass blocked)

Reference Implementation

FLOOR_COST_PER_AUTH = 6464  # 101 bytes * 4 tokens/byte * 16 gas/token


def calculate_intrinsic_cost(tx: Transaction) -> Tuple[Uint, Uint]:
    """
    Calculate intrinsic gas cost and floor gas cost.
    Returns (intrinsic_gas, floor_gas).
    """
    # Calldata tokens
    calldata_zero = sum(1 for b in tx.data if b == 0)
    tokens_in_calldata = Uint(calldata_zero + (len(tx.data) - calldata_zero) * 4)

    # Authorization costs
    num_authorizations = Uint(0)
    auth_exec_cost = Uint(0)
    if isinstance(tx, SetCodeTransaction):
        num_authorizations = Uint(len(tx.authorizations))
        auth_exec_cost = PER_EMPTY_ACCOUNT_COST * num_authorizations

    # Floor: calldata + flat cost per authorization
    floor_gas = (
        TX_BASE_COST
        + tokens_in_calldata * TOTAL_COST_FLOOR_PER_TOKEN
        + num_authorizations * FLOOR_COST_PER_AUTH
    )

    # Intrinsic: calldata + create + access list + authorization execution cost
    calldata_cost = tokens_in_calldata * STANDARD_TOKEN_COST
    create_cost = TX_CREATE_COST + init_code_cost(tx.data) if is_create(tx) else 0
    intrinsic_gas = (
        TX_BASE_COST
        + calldata_cost
        + create_cost
        + access_list_cost
        + auth_exec_cost
    )

    return intrinsic_gas, floor_gas

Security Considerations

This EIP closes a loophole that allows circumventing EIP-7623 floor pricing. Without this fix, adversaries can achieve larger blocks than intended by combining calldata with authorization data.

Interaction with EIP-7981

If EIP-7981 is also adopted, both EIPs work together: access list tokens and authorization tokens are both included in the floor calculation. There are no conflicts.

Copyright

Copyright and related rights waived via CC0.

Citation

Please cite this document as:

Toni Wahrstätter (@nerolation), "EIP-8131: Add Auth Data to EIP-7623 Floor [DRAFT]," Ethereum Improvement Proposals, no. 8131, January 2025. Available: https://eips.ethereum.org/EIPS/eip-8131.