EIP-2780: 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 6,000 from additional costs related to the to account.

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 = 2,000.
• Specify that a PAY-style value-move primitive, if present, does not warm its recipient and never loads code (charged at COLD_ACCOUNT_COST_NOCODE if not already warmed).

Capacity impact (illustrative):

• Average: about +20.8% more transactions per block at unchanged gas limit.
• Max: up to ~320% more minimal transactions (pure ETH transfers).
• Equivalent gas-limit effect: roughly +20.8% (for example, 60M -> ~72.5M), with calldata and access-list metering unchanged.

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 gaslimits 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.

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)

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 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 and a STATE_UPDATE of the to address, so the effective minimal productive tx cost is 6,000.
• 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,000charge 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 30,000 (4,500 base + 500 lookup + 25,000 new-account surcharge).

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

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
Total	30,000	Sum of above (4,500 + 500 + 25,000)

Notes:

• If value = 0 and to is empty per EIP-161, no account is created and no surcharge applies.
• CREATE transactions are unchanged; their cost already includes account creation.

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):

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 recipient exists: CALL_VALUE_COST = 2 * STATE_UPDATE = 2,000.
  • If recipient is EIP-161-empty: CALL_VALUE_COST = STATE_UPDATE + GAS_NEW_ACCOUNT = 26,000.
  • 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.

  The CALL_VALUE_COST = 2,000 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.
  • A PAY-style pure value-move primitive, if present, does not warm its recipient and never loads code. It pays WARM_STATE_READ = 100 if warm for unrelated reasons, else COLD_ACCOUNT_COST_NOCODE = 500, plus the value-write cost above.

• 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. (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	4,500
(NOP) No-transfer to empty account	TX_BASE_COST	4,500
(NOP) ETH transfer to self	TX_BASE_COST	4,500
ETH Transfer to existing EOA	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + STATE_UPDATE	6,000
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 + execution	8,100 + execution
ETH Transfer creating new account	TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + GAS_NEW_ACCOUNT	30,000

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.
• 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) and one recipient leaf write, so its total is 6,000.

CREATE is unchanged because its cost already includes account creation. 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 unstablity as gas_limit depends on signiture 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 ~6,000 gas vs a permissioned ERC-20/LST/stablecoin transfer at ~48,000 gas, you get ~8x 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: 6,000 gas (TX_BASE_COST + COLD_ACCOUNT_COST_NOCODE + STATE_UPDATE).

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 6,000 gas

Binding point for size-cap dominance: 76,260 * 6,000 = 457,560,000 gas. At gaslimits below ~457.56 M, gas limits tx count; above it, the 8 MiB size cap dominates.

Block gaslimit	Old tx/bk (21k)	New tx/bk (6k)	TPS @ 12s	TPS @ 6s	TPS @ 3s	TPS @ 1.5s
45 M	2,142	7,500	625	1,250	2,500	5,000
60 M	2,857	10,000	833	1,667	3,333	6,667
100 M	4,761	16,666	1,389	2,778	5,555	11,111
200 M	9,523	33,333	2,778	5,556	11,111	22,222
450 M	21,428	75,000	6,250	12,500	25,000	50,000

Changes for common types of txs

Transaction Type	Old Cost	New Cost	Change
Simple ETH transfer (existing EOA)	21,000	6,000	−71 %
ETH transfer creating new EOA	21,000	30,000	+43 %
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 30,000 (4,500 base + 500 + 25,000 surcharge).
2. value > 0 to a precompile: intrinsic 4,500 (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 = 4,500, no surcharge.
10. Self-transfer from == to: total = 4,500.
11. Internal CALL repricing
    • Internal CALL to existing EOA with value: CALL_VALUE_COST = 2,000 plus cold/warm costs.
    • Internal CALL to EIP-161-empty: CALL_VALUE_COST = 26,000.
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 6,000-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.