---
eip: 2780
title: Reduce intrinsic transaction gas
description: Reduce intrinsic transaction gas and charge 25k when a value transfer creates a new account
author: Matt Garnett (@lightclient), Uri Klarman (@uriklarman), Ben Adams (@benaadams), Maria Inês Silva (@misilva73), Anders Elowsson (@anderselowsson), Anthony Sassano (@sassal)
discussions-to: https://ethereum-magicians.org/t/eip-2780-reduce-intrinsic-cost-of-transactions/4413
status: Draft
type: Standards Track
category: Core
created: 2020-07-11
requires: 1559, 2718, 2929, 2930, 7708
---

## 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](./eip-7708.md) 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](./eip-7708.md) 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](./eip-7934.md) 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](./eip-7708.md) LOG3 transfer event (375 + 3×375 + 32×8)     |

The intrinsic gas accounting defined here overrides [EIP-2929](./eip-2929.md)'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](./eip-2929.md) 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](./eip-7708.md) 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](./eip-161.md) 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](./eip-161.md), 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):

```python
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

    if tx.is_create() == False and tx.value > 0 and 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](./eip-7708.md) 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](./eip-7708.md) 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](./eip-2930.md)) 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`                                                   | 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` + `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**     |
| 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](./eip-2930.md) (Access List).** Intrinsic gas is `TX_BASE_COST` after `FORK_BLOCK`. Access lists keep their existing per-entry charges and warming semantics.
- **[EIP-2929](./eip-2929.md) (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](./eip-7702.md) (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.
- **[EIP-7708](./eip-7708.md) (ETH transfers emit a log).** EIP-7708 emits a LOG3 transfer event for every nonzero-value ETH transfer. Under the legacy `21,000` base this cost was absorbed; with a reduced base it must be charged explicitly. This EIP introduces `TRANSFER_LOG_COST = 1,756` (LOG3 equivalent: `375 + 3×375 + 32×8`) applied to top-level value transfers, value-moving `CALL`s, and nonzero-value `SELFDESTRUCT` when it transfers value to a different account; for `SELFDESTRUCT`, the charge is applied at the point that transfer is processed.
- **Calldata-pricing EIPs (e.g. [EIP-7623](./eip-7623.md)).** 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](./eip-7708.md) transfer log, so its total is `7,756`.

`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](./eip-7623.md) and [EIP-7976](./eip-7976.md). 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](./eip-2718.md) 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](./eip-7623.md) or [EIP-7976](./eip-7976.md)) 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).

![Figure 1](../assets/eip-2780/1.png)

### Effects on transactions per block

For execution-payload size, use [EIP-7934](./eip-7934.md)’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](./eip-7934.md).
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](./eip-6780.md), 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](../LICENSE.md).