Reduce intrinsic transaction gas

Abstract

Reduce the intrinsic cost TX_BASE_COST from 21,000 to 4,500 and define a consistent gas accounting model based on actual state operations. This more granular approach makes a simple ETH transfer 7,756 due to additional costs related to the to account and the EIP-7708 transfer log.

If a non-create transaction has value > 0 and targets a non-existent account, charge GAS_NEW_ACCOUNT = 25,000 to align with CALL account creation and price in state growth. When this surcharge applies, the recipient pays exactly one cold non-code touch; no code-load cost applies.

This EIP does not change calldata or access-list metering. It also refines related gas schedule items used in derivation and execution accounting:

• Split cold-account touches into COLD_ACCOUNT_COST_CODE = 2,600 and COLD_ACCOUNT_COST_NOCODE = 500.
• Introduce STATE_UPDATE = 1,000 as the price of a single account-leaf write.
• Reprice value-moving calls as account-leaf writes, replacing CALL_VALUE_COST = 9,000 with CALL_VALUE_COST = 2 * STATE_UPDATE + TRANSFER_LOG_COST = 3,756.
• Charge TRANSFER_LOG_COST = 1,756 for the EIP-7708 transfer log emitted on every nonzero-value transfer to a different account.

Capacity impact (illustrative):

Metric	Result	Change	Description
Max (minimal txs)	13,333 tx / block	+367%	4,500-gas minimal transactions per 60 M block
Max (ETH transfers)	7,735 tx / block	+171%	7,756-gas ETH transfers per 60 M block
Throughput (minimal txs)	~1,111 TPS	+367%	4,500-gas minimal transactions per 60 M block per 12sec
Throughput (ETH transfers)	~645 TPS	+171%	7,756-gas ETH transfers per 60 M block per 12sec
Equivalent gas-limit uplift	≈ +20.8%	-	Effective throughput gain for avg tx usage (e.g., 60 M => ~72.5 M)

Motivation

Monetary Context

Money has three basic functions: a unit of account, a medium of exchange, and a store of value. ETH already meets the last two by design. It carries value without an issuer and settles with finality. Where it falls short is in everyday exchange - the friction of use rather than the nature of the asset.

ETH underpins most onchain liquidity. Pairs are denominated in it, and gas is paid in it - a de-facto tax base that anchors value. Bitcoin's monetary role now runs mainly through exchange pairs, hence its drift in focus to store-of-value rather than medium-of-exchange. ETH still clears real activity onchain, yet outside NFTs few people think in ETH terms. In that niche ETH already functions as both unit and medium, but only for high-value items.

For ETH to operate fully as money, it must also handle small transactions. That was impractical when gas sat at 300 gwei, or even 90 gwei on quiet weekends. Post-4844, blobs absorb L2's "pay at any price" data and higher gas limits ease congestion; cost, not capacity, is the bottleneck.

EIP-2780 lowers that fixed cost. By aligning the base gas with the real work of a transaction and by correcting CALL value pricing, it removes the legacy penalty on simple payments. Small transfers become viable again without subsidising calldata or storage. The same logic charges properly for new-account creation, so state growth remains priced in.

• Unit of account: When transfers are cheap and regular, people price in ETH because they use it directly. This proposal turns that habit into equilibrium rather than idealism.

• Medium of exchange: Reducing TX_BASE_COST eliminates the old friction that slowed native circulation. Settlement becomes frequent, not occasional.

• Store of value: Honest pricing reinforces confidence that ETH's cost structure is grounded in real computation, not arbitrary constants.

• Velocity: Lower friction raises the rate of final settlement; more frequent, smaller clears in native ETH, without altering calldata or storage economics.

• Monetary competition: Stablecoins and LSTs are welcome, but they compete for onchain "moneyness". Making native ETH easy to spend keeps it central; not just the fuel, but the money of the system.

Note: This proposal doesn't target ETH specifically, the lower base cost applies to every transaction type. However since TX_BASE_COST makes up nearly all of an ETH transfer's gas, while it's only a small fraction of contract calls, ETH loses the most friction and gains the most velocity.

Specifics

The legacy 21,000 base no longer matches the universal work path under warm/cold accounting. Decomposed into signature recovery, one account-leaf write for the sender (nonce + balance coalesced), and one cold non-code touch (sender), the universal path totals 4,500 gas.

State growth is underpriced for top-level value transfers that create accounts, while CALL pays explicit creation. Charging 25,000 when a transfer creates an account aligns entry points and internalizes state growth.

A lower base removes the distortion that over-incentivized batching solely to dodge TX_BASE_COST, without subsidizing calldata or storage. The refinement of value-transfer costs and cold-account pricing makes execution charges proportional to actual state work: account touches and leaf writes.

We intentionally do not charge per-byte gas for the transaction envelope (nonce, gas*, to, value, v, r, s). Calldata pricing applies only to tx.data. A plain ETH payment has empty tx.data, so it pays zero calldata gas. Lowering TX_BASE_COST to the universal work path makes ETH payments cheaper without subsidizing arbitrary calldata.

Throughput, payload, and basefee dynamics

This EIP affects three independent levers:

1. Gas-limit equivalence: Reducing the base cost from 21,000 to 4,500 increases transaction capacity at a fixed block gaslimit by approximately +20.8%.

2. Payload-size bounds: Per EIP-7934 the execution payload cap is MAX_RLP_BLOCK_SIZE = 10,485,760 - 2,097,152 = 8,388,608 bytes. Payload size, not gas, may become the dominant block-size constraint at high gaslimits.

3. Basefee market dynamics: Lower intrinsic gas reduces the average gas per tx, temporarily increasing utilisation and causing short-term downward adjustment in basefee. Over time, equilibrium restores as inclusion policies adapt.

These levers are independent; this proposal changes only intrinsic gas, not calldata metering or access-list pricing.

Monetary Effects

Reducing ETH transfer cost from 21,000 => 7,756 gas increases both transaction frequency and viable payment granularity. At a fixed basefee, smaller payments become economical, raising the velocity of money - how often ETH changes hands on L1.

Let $g$ be gas per transaction, $b$ the basefee (in gwei), and $r$ the user's tolerated fee share of payment value.

$v_{\text{min}} = \frac{g \times b \times 10^{-9}}{r}$

Since $g$ drops from $21,000$ to $7,756$:

$\frac{v_{\text{min,new}}}{v_{\text{min,old}}} = \frac{7{,}756}{21{,}000} \approx 0.37$

The minimum economical L1 payment falls by about 63 %, allowing more, smaller transfers to clear directly in ETH.

From the quantity relation $M V = P Q$, with $M$ and $P$ roughly constant over short periods:

$V_{\text{new}} / V_{\text{old}} \approx Q_{\text{new}} / Q_{\text{old}}$

Pure ETH-transfer capacity rises roughly 2.7x (+171 %), and the lower $v_{\text{min}}$ further increases $Q$ as more small-value payments become viable.

Together these effects lift $V$, more frequent, smaller, native settlements without changing monetary supply.

ETH thus gains moneyness:

• Medium of exchange: direct use becomes routine, not exceptional.
• Unit of account: frequent native settlement encourages ETH-denominated pricing.
• Store of value: workload-based fees reinforce trust in cost realism.

Price volatility may still lead users to prefer stablecoins for predictability, but this change removes unnecessary friction, restoring ETH’s competitiveness wherever volatility is tolerable.

The 25,000 surcharge for new-account creation continues to price state growth honestly while everyday transfers become cheaper and faster.

Equivalent gas-limit increase

Lowering TX_BASE_COST from 21,000 to 4,500 removes up to 16,500 gas per transaction. Using recent totals of 163 Ggas/day and 1.7 M tx/day:

Metric	Calculation	Result	Change
Avg gas per tx	163Bn / 1.7M	≈ 95,882 gas	-
New avg gas per tx	95,882 − 16,500	≈ 79,382 gas	-
Throughput at fixed gaslimit	95,882 / 79,382	≈ x1.208	+20.08%
Daily tx at same gas usage	1.7M × 1.208	≈ 2.053M tx/day	+340k/day

Perfnet measurements show EL clients handle >300 MGas/s for pure ETH transfers. Expressed under a 4.5k base this corresponds to 300 * (4.5/21) ~ 64.3 MGas/s, i.e. ~771 MGas per 12 s slot. This indicates sufficient headroom and that the current base is significantly overcharged, so no extra engineering is required to improve performance to support this change.

Net effect equals raising a 45 M gas limit to ~54.4 M at unchanged calldata and access-list metering. This directly advances Scaling L1.

Specification

After FORK_BLOCK, set the following parameters and rules:

Parameters

Name	Value	Description
TX_BASE_COST	4,500	Base cost of any transaction
GAS_NEW_ACCOUNT	25,000	Surcharge when a value-transferring transaction creates a new account
STATE_UPDATE	1,000	One account-leaf write in the account trie (nonce and balance coalesce)
COLD_ACCOUNT_COST_CODE	2,600	Cold touch of an account with code
COLD_ACCOUNT_COST_NOCODE	500	Cold touch of an account known to have no code
WARM_STATE_READ	100	Touch of an already-warm account (same as WARM_STORAGE_READ_COST)
TRANSFER_LOG_COST	1,756	EIP-7708 LOG3 transfer event (375 + 3×375 + 32×8). See EIP-7708 for the full set of emission sites and their charging points.

The intrinsic gas accounting defined here overrides EIP-2929's blanket "all tx addresses are warm" rule.

A transaction’s intrinsic base is decomposed into explicit primitives, so warmth must be priced explicitly.

• tx.sender is charged as a cold non-code account (COLD_ACCOUNT_COST_NOCODE = 500), representing the first access and coalesced account-leaf update.

• tx.to is charged based on its type:

  • if a contract create, charge under those rules.

  • if an EOA or an empty account, use COLD_ACCOUNT_COST_NOCODE = 500.

  • if a contract, use COLD_ACCOUNT_COST_CODE = 2,600.

  • if a EIP-7702 delegated account, use COLD_ACCOUNT_COST_CODE = 2,600. The delegation target incurs an additional COLD_ACCOUNT_COST_CODE = 2,600 if cold, or WARM_STATE_READ = 100 if already warm.

  • if a precompile, it is warm at tx start and charged zero.

• Warmth discovered through an access list still applies and overrides the cold cost.

This decomposition replaces the implicit warmth assumptions of EIP-2929 and makes the per-account cost explicit in the base or the execution phase as appropriate.

Notes:

• STATE_UPDATE counts writes at the account-leaf granularity. If a single account's nonce and balance both change in one transition, charge one STATE_UPDATE.
• COLD_ACCOUNT_COST_NOCODE reflects that non-code accounts do not load code or a storage trie, so have a lower warming cost.
• A regular ETH transfer additionally includes a cold touch of at least COLD_ACCOUNT_COST_NOCODE, a STATE_UPDATE of the to address, and a TRANSFER_LOG_COST for the EIP-7708 transfer log, so the effective minimal productive tx cost is 7,756.
• Not including the to cold warming and STATE_UPDATE in TX_BASE_COST means a contract-interaction transaction that does not transfer value does not unnecessarily pay these additional costs.

Derivation (non-normative)

Decomposition of the base cost into universal primitives:

Component	Cost	Notes
ECRECOVER	3,000	Elliptic curve signature recovery
STATE_UPDATE	1,000	One account-leaf write (nonce + balance coalesced)
COLD_ACCOUNT_COST_NOCODE	500	Sender is cold and has no code
TX_BASE_COST	4,500	Sum of above (3,000 + 1,000 + 500)

New-account surcharge

Apply GAS_NEW_ACCOUNT when all are true:

1. The transaction is not a CREATE transaction.
2. value > 0.
3. to is not a precompile.
4. to is non-existent per EIP-161 emptiness at the start of transaction execution.

The GAS_NEW_ACCOUNT = 25,000 charge covers state growth (new leaf creation and one STATE_UPDATE). An additional COLD_ACCOUNT_COST_NOCODE = 500 applies for the initial lookup to determine that the account does not exist.

Thus, the total intrinsic gas for a value-transferring transaction to a new account is 31,756 (4,500 base + 500 lookup + 25,000 new-account surcharge + 1,756 transfer log).

For reference, the total charges for such transfers change from 21,000 to 31,756.

Component	Cost	Notes
TX_BASE_COST	4,500	Base transaction cost
COLD_ACCOUNT_COST_NOCODE	500	Recipient cold lookup (execution charge)
GAS_NEW_ACCOUNT	25,000	Account creation, includes leaf write
TRANSFER_LOG_COST	1,756	EIP-7708 transfer log
Total	31,756	Sum of above (4,500 + 500 + 25,000 + 1,756)

Notes:

• If value = 0 and to is empty per EIP-161, no account is created and no surcharge applies.
• Top-level CREATE transactions with value > 0 (see Pseudocode) pay TRANSFER_LOG_COST for the EIP-7708 transfer log emitted on the endowment transfer.

Intrinsic gas computation

Clients compute intrinsic gas as today for each typed transaction except:

• Replace any hardcoded 21,000 with TX_BASE_COST = 4,500.
• Add GAS_NEW_ACCOUNT when the New-account surcharge conditions hold.

Pseudocode (normative):

def CalculateIntrinsicGas(tx, state_at_start):
    gasCost = TX_BASE_COST

    # Existing rules for calldata and access lists remain unchanged by this EIP.
    gasCost += GasForCalldata(tx.data)                  # per active calldata pricing EIPs
    if tx.has_access_list():
        gasCost += GasForAccessList(tx.access_list)     # per EIP-2930

    # Charge for the EIP-7708 transfer log emitted on the tx-level value
    # transfer. CREATE transactions endow a freshly computed contract
    # address that is, by construction, distinct from the sender, so the
    # log applies whenever value > 0.
    if tx.value > 0 and (tx.is_create() or tx.sender != tx.to):
        gasCost += TRANSFER_LOG_COST                    # EIP-7708 transfer log

    if tx.is_create() == False
       and tx.value > 0
       and is_precompile(tx.to) == False
       and is_nonexistent_per_eip161(state_at_start, tx.to):
        gasCost += GAS_NEW_ACCOUNT

    return gasCost

EVM gas schedule adjustments

These changes refine execution-layer accounting to align with the primitives above.

• Value-moving calls. Replace the legacy CALL_VALUE_COST = 9,000 with:

  • If caller == to (self-call): CALL_VALUE_COST = STATE_UPDATE = 1,000. No TRANSFER_LOG_COST is charged because EIP-7708 does not emit a transfer log for self-transfers.
  • If recipient exists and caller != to: CALL_VALUE_COST = 2 * STATE_UPDATE + TRANSFER_LOG_COST = 3,756.
  • If recipient is EIP-161-empty and caller != to: CALL_VALUE_COST = STATE_UPDATE + GAS_NEW_ACCOUNT + TRANSFER_LOG_COST = 27,756.
  • This charge is in addition to warm/cold account-touch costs per EIP-2929 and the existing CALL base cost. This EIP does not modify the CALL base cost.
  • TRANSFER_LOG_COST covers the EIP-7708 transfer log emitted for every nonzero-value transfer to a different account.

  The CALL_VALUE_COST applies for all value-carrying calls, regardless of whether the callee's account has already been updated earlier in the same transaction. This ensures the 2300-gas stipend mechanism remains safe and consistent for simple value forwarding and does not retroactively depend on account-update history.

• Cold-account touches.

  • Use COLD_ACCOUNT_COST_CODE = 2,600 when touching an account with code.
  • Use COLD_ACCOUNT_COST_NOCODE = 500 when touching an account known to have no code.

• Warmth policy.

  • Access-list entries (charged via EIP-2930) and precompiles are warm at tx start.
  • CALL warms its to after charging the appropriate cold cost if cold.

• Self-transfers. If from == to, only one STATE_UPDATE occurs. The sender's nonce and balance update are coalesced into the same leaf write. No recipient lookup or separate write is charged. (It is a NOP tx other than charging gas and incrementing nonce).

Transaction reference cases

Case	Formula	Total Cost
(NOP) No-transfer to EOA	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE	5,000
(NOP) No-transfer to empty account	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE	5,000
(NOP) ETH transfer to self	TX_BASE_COST	4,500
ETH Transfer to existing EOA	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + STATE_UPDATE + TRANSFER_LOG_COST	7,756
No-transfer to contract	TX_BASE_COST + COLD_ACCOUNT_COST_CODE + execution	7,100 + execution
ETH Transfer to contract	TX_BASE_COST + COLD_ACCOUNT_COST_CODE + STATE_UPDATE + TRANSFER_LOG_COST + execution	9,856 + execution
No-transfer to 7702 delegated	TX_BASE_COST + 2 * COLD_ACCOUNT_COST_CODE + execution	9,700 + execution
ETH Transfer to 7702 delegated	TX_BASE_COST + 2 * COLD_ACCOUNT_COST_CODE + STATE_UPDATE + TRANSFER_LOG_COST + execution	12,456 + execution
ETH Transfer creating new account	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + GAS_NEW_ACCOUNT + TRANSFER_LOG_COST	31,756

This aligns costs with actual state work rather than legacy flat surcharges.

Edits and interactions with other EIPs

• EIP-2930 (Access List). Intrinsic gas is TX_BASE_COST after FORK_BLOCK. Access lists keep their existing per-entry charges and warming semantics.
• EIP-2929 (Gas cost increases for state access). Refined by this EIP to price non-code cold touches at 500 and code-account cold touches at 2,600.
• EIP-7702 (Set EOA Code). TX_BASE_COST remains 4,500 even if the sender temporarily assumes code for the transaction. Clients must not perform any disk code-load to determine sender type, since 7702 provides code inline. If the transaction executes code that reads or executes its own code, normal COLD_ACCOUNT_COST_CODE or WARM_STATE_READ costs apply at execution time as per the standard cold/warm model. When tx.to is a 7702-delegated account, it is charged COLD_ACCOUNT_COST_CODE = 2,600 at the intrinsic level. Resolving the delegation requires loading code from the delegation target, which incurs its own COLD_ACCOUNT_COST_CODE = 2,600 if the target is cold, or WARM_STATE_READ = 100 if already warm. This also applies to calls made to delegated accounts.
• EIP-7708 (ETH transfers emit a log). EIP-7708 emits a LOG3-shaped transfer event on every non-zero-value ETH transfer to a different account, and a LOG2-shaped burn event when ETH leaves circulation. Under the legacy 21,000 intrinsic base, the LOG3 cost of a transfer event was implicitly absorbed; with TX_BASE_COST reduced to 4,500, that subsidy disappears and each emission must be priced explicitly. This EIP charges TRANSFER_LOG_COST = 1,756 (LOG3 equivalent: 375 + 3×375 + 32×8) at intrinsic gas computation (see Pseudocode) for top-level value-transferring transactions, including CREATE transactions with value > 0. The corresponding in-EVM transfer-log and burn-log charges (CALL, SELFDESTRUCT, CREATE / CREATE2) are specified in EIP-7708.
• EIP-7928 (Block-Level Access Lists). The two-tier cold-access model (COLD_ACCOUNT_COST_NOCODE vs COLD_ACCOUNT_COST_CODE) requires loading the account from disk before the correct charge can be determined. For cold accounts, at least COLD_ACCOUNT_COST_NOCODE gas must be available before account access is attempted; if unavailable, the operation fails with out-of-gas without accessing the account. Once an account access is attempted, the account is added to the transaction's accessed set for the BAL. Thereafter, if the account is found to have code, the account read remains in the BAL even if the available gas is less than COLD_ACCOUNT_COST_CODE and the call frame fails with out-of-gas.
• Calldata-pricing EIPs (e.g. EIP-7623). Unchanged. This EIP does not alter calldata pricing.

Rationale

Price only what every transaction always does: ECDSA recovery, warming sender and to, and one account-leaf write for the sender (nonce + balance change). That sums to 4,500 gas. Anything not universal should be metered separately.

Calldata remains metered per byte. No calldata allowance is folded into the base. This reinforces ETH as money and payments: a plain ETH transfer carries no calldata, executes no bytecode, and touches no contract storage slots. It adds exactly one recipient touch (when not a smart contract), one recipient leaf write, and one EIP-7708 transfer log, so its total is 7,756.

The GAS_NEW_ACCOUNT surcharge does not apply to CREATE/CREATE2: the GAS_CREATE = 32,000 opcode base already prices account creation, and top-level CREATE transactions are not charged GAS_CREATE at all. Top-level CREATE transactions with value > 0 do pay TRANSFER_LOG_COST for the EIP-7708 transfer log. Access-list pricing is unchanged.

Legacy pricing undercharged top-level ETH transfers that created new accounts relative to internal CALL-based creations. This EIP corrects that by charging GAS_NEW_ACCOUNT = 25,000, identical to the CALL account-creation surcharge, ensuring consistent pricing for state growth regardless of entry path.

This removes cross-subsidies, aligns charges with resources, and keeps costs equal across paths that perform the same state growth.

Do not fold any calldata allowance into the base. The envelope RLP (nonce, gas*, to, value, v, r, s) is not charged as calldata and remains unmetered per byte. Only tx.data bytes are metered at the existing calldata schedule, and access lists keep their per-entry costs. A vanilla ETH transfer executes no bytecode and touches no contract storage slots; it performs signature recovery, warms the sender, and updates sender and recipient accounts. It therefore receives the base discount and pays only the additional recipient costs.

Bundling multiple transfers into a single contract call avoids repeated TX_BASE_COST, but those transfers then execute serially inside one EVM context. That blocks parallel execution. With a lower per-tx base cost, users have less incentive to bundle, so more transfers remain independent transactions. Independent transactions can be scheduled across threads, which improves parallelism at the client and execution-layer level.

Thus, reducing TX_BASE_COST not only corrects mispricing but also increases the share of transactions that are naturally parallelizable.

This EIP composes cleanly with calldata-pricing proposals such as EIP-7623 and EIP-7976. Those EIPs affect tx.data metering, while this EIP adjusts only transaction-level intrinsic accounting. There is no overlapping scope.

Why not charge full tx data as calldata?

• Intrinsic coupling to signed fields. Pricing full-transaction bytes would make intrinsic gas depend on gas_limit and variable-length signature elements, creating fixed-point estimation issues and incentives for signature-length selection as well as iteration instability as gas_limit depends on signature which contains gas_limit.

• Serialization neutrality. A fee rule keyed to RLP size couples costs to one encoding and weakens EIP-2718 type neutrality and future formats such as SSZ. Calldata is treated as opaque bytes so it avoids this coupling.

• Policy targeting and market floor. Calldata floors (for example EIP-7623 or EIP-7976) price bytes in tx.data to bound EL payload and steer data to blobs; envelope bytes are control-plane. The TX_BASE_COST is the smallest tx size, and having a low encoding-agnostic intrinsic base keeps the minimum inclusion price coupled to the basefee market, without opening a DoS vector.

• Native settlement and unit-of-account. Even though all transactions receive the same absolute gas reduction, it proportionally improves pristine ETH transfers more. With an ETH transfer at ~7,756 gas vs a permissioned ERC-20/LST/stablecoin transfer at ~48,000 gas, you get ~6x higher payment throughput per unit gas, which reinforces ETH as the settlement asset and reduces reliance on contract-based money (which carries smart contract risk, operator risk, governance risk and censorship risks via smart contract operator).

Effects on transactions per block

For execution-payload size, use EIP-7934’s 8 MiB uncompressed cap: 8,388,608 bytes. A typical EIP-1559 ETH transfer encodes at roughly ~110 bytes, yielding a size cap of floor(8,388,608 / 110) = 76,260 tx per block when size, not gas, is the binding constraint.

There are two useful ceilings to consider:

• Minimal transaction with no value and no execution: TX_BASE_COST = 4,500 gas.
• Minimal ETH payment to an existing EOA: 7,756 gas (TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + STATE_UPDATE + TRANSFER_LOG_COST).

Counts below are floor(gaslimit / per-tx-gas), then capped by 76,260 when the 8 MiB size limit binds. TPS figures round to the nearest integer.

Scenario A: minimal txs at 4,500 gas

Binding point for size-cap dominance: 76,260 * 4,500 = 343,170,000 gas. At gaslimits above ~343.17 M, block size, not gas, limits the tx count for 4,500-gas transactions.

Block gaslimit	Old tx/bk (21k)	New tx/bk (4.5k)	TPS @ 12s	TPS @ 6s	TPS @ 3s	TPS @ 1.5s
45 M	2,142	10,000	833	1,667	3,333	6,667
60 M	2,857	13,333	1,111	2,222	4,444	8,889
100 M	4,761	22,222	1,852	3,704	7,407	14,815
200 M	9,523	44,444	3,704	7,407	14,815	29,629
450 M	21,428	†76,260	6,355	12,710	25,420	50,840

† Size cap binds at 450 M because 450 M > 343.17 M.

Scenario B: ETH transfers at 7,756 gas

Binding point for size-cap dominance: 76,260 * 7,756 = 591,472,560 gas. At gaslimits below ~591.47 M, gas limits tx count; above it, the 8 MiB size cap dominates.

Block gaslimit	Old tx/bk (21k)	New tx/bk (7,756)	TPS @ 12s	TPS @ 6s	TPS @ 3s	TPS @ 1.5s
45 M	2,142	5,801	483	967	1,934	3,867
60 M	2,857	7,735	644	1,289	2,578	5,157
100 M	4,761	12,893	1,074	2,149	4,298	8,595
200 M	9,523	25,786	2,149	4,298	8,595	17,191
450 M	21,428	58,019	4,835	9,670	19,340	38,680

Changes for common types of txs

Transaction Type	Old Cost	New Cost	Change
Simple ETH transfer (existing EOA)	21,000	7,756	−63 %
ETH transfer creating new EOA	21,000	31,756	+51 %
ERC-20 transfer (typical)	63,200	48,200	−24 %
ERC-20 transfer (Solady)	33,400	18,400	−45 %
Uniswap v3 swap	184,500	169,500	−8 %
Uniswap v3 add-liquidity	216,900	201,900	−7 %

Reference MGas/s for gaslimit vs slot time

Block gaslimit	MGas/s @ 12s	MGas/s @ 6s	MGas/s @ 3s	MGas/s @ 1.5s
45 M	3.75	7.50	15.00	30.00
60 M	5.00	10.00	20.00	40.00
100 M	8.33	16.67	33.33	66.67
200 M	16.67	33.33	66.67	133.33
450 M	37.50	75.00	150.00	300.00

Backwards Compatibility

This EIP is not backward compatible. It is a consensus gas repricing that must be activated at FORK_BLOCK.

Wallets, RPCs, gas estimators, and any logic that assumes a 21,000 base must update.

Test Cases

While the benefits of reducing transactions' intrinsic cost are apparent, such a change should be applied if it imposes no negative externalities, or if such effects are negligible.

Tests should be created with blocks of just ETH transfers and tested on Perfnet across all EL clients to ensure the pricing is correct.

Add explicit test vectors (intrinsic gas only):

1. value > 0 to an empty EOA (non-existent per EIP-161): intrinsic 31,756 (4,500 base + 500 + 25,000 surcharge + 1,756 transfer log).
2. value > 0 to a precompile: intrinsic 6,256 (4,500 base + 1,756 transfer log; no surcharge; precompiles are warm at tx start).
3. value = 0 to an empty address: intrinsic 4,500 (no creation, no surcharge).
4. CREATE transaction: unchanged from prior rules.
5. EIP-7702 transaction with and without access list: intrinsic uses TX_BASE_COST plus unchanged access-list costs.
6. Block of txs calling minimal gas contract execution with maximal contract size addresses (so VM is activated for every tx).
7. Warmth and access list interplay
   • ETH transfer to existing EOA without access list: charge COLD_ACCOUNT_COST_NOCODE = 500 for recipient lookup.
   • Same transaction with recipient in access list: charge WARM_STATE_READ = 100.
8. 7702 interactions
   • 7702 tx where sender assumes code and calls nothing: intrinsic = 4,500, no extra cold-code cost.
   • 7702 tx where sender assumes code and executes self-code: charge COLD_ACCOUNT_COST_CODE when first loaded.
9. Precompile transfers
   • value > 0 to 0x01–0x09: intrinsic = 6,256 (4,500 base + 1,756 transfer log), no surcharge.
10. Self-transfer from == to: total = 4,500.
11. Internal CALL repricing
    • Internal CALL to existing EOA with value: CALL_VALUE_COST = 3,756 plus cold/warm costs.
    • Internal CALL to EIP-161-empty: CALL_VALUE_COST = 27,756.
12. Zero-value edge cases value = 0 to empty address: intrinsic = 4,500.
13. Perfnet stress
    • Fill block with minimal 4,500-gas tx and 7,756-gas ETH transfers; confirm gas vs byte-size binding per EIP-7934.
14. SELFDESTRUCT test: Create-and-destroy in one tx; confirm normal value-transfer costs apply, no deletion repricing.

Security Considerations

As this significantly increases the max tx per block, this carries risk.

However, this pricing should be the same as performing the component changes inside the transaction; and it factors in the additional costs from state growth which were not originally in the transaction base price.

Current gaslimit testing mostly uses a block with a single transaction; so this should not cause unexpected load compared to what is already being tested.

The semantics of SELFDESTRUCT remain unchanged. Following EIP-6780, only contracts created within the same transaction may be fully deleted. This EIP does not reprice or modify any SELFDESTRUCT side-effects.

Copyright

Copyright and related rights waived via CC0.