| Client | Branch | Commit | Spec commit |
|---|---|---|---|
| Geth — ethereum/go-ethereum | master | [8817f99f92852f8ac53e596de6202dd9e3494065](https://github.com/ethereum/go-ethereum/commit/8817f99f92852f8ac53e596de6202dd9e3494065) | [7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b](https://github.com/ethereum/execution-specs/commit/7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b) |
| Nethermind — NethermindEth/nethermind | master | [d48833af88ec4224c86afadd1c596e8f619c406b](https://github.com/NethermindEth/nethermind/commit/d48833af88ec4224c86afadd1c596e8f619c406b) | [7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b](https://github.com/ethereum/execution-specs/commit/7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b) |
| Besu — besu-eth/besu | main | [aa06c4f8dfc461e483d46c6a1ac72b5bfef8d945](https://github.com/besu-eth/besu/commit/aa06c4f8dfc461e483d46c6a1ac72b5bfef8d945) | [7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b](https://github.com/ethereum/execution-specs/commit/7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b) |

Batch **el-intrinsic**, merge **01**. Pins and review outcomes are inherited from the three supplied items, dated 2026-10-27; this merge does not refresh them or add findings. All three use execution-specs branch **forks/bogota**, directory `src/ethereum/forks/amsterdam/`, at the same commit. The Geth item notes that tracker #3217 instead names forks/amsterdam; its review deliberately uses forks/bogota.

Additional pin provenance:

| Source | Branch/ref | Pin or provenance |
|---|---|---|
| Geth pin API | master | https://api.github.com/repos/ethereum/go-ethereum/commits/master; item reports commit date 2026-10-27T03:32:47Z and matching shallow-clone HEAD |
| Nethermind pin API | master | https://api.github.com/repos/NethermindEth/nethermind/commits/master; Geth item reports commit date 2026-10-27T12:00:20Z and matching shallow-clone HEAD |
| Besu pin API | main | https://api.github.com/repos/besu-eth/besu/commits/main; item reports commit date 2026-10-27T13:41:33Z and matching shallow-clone HEAD |
| execution-specs pin API | forks/bogota | https://api.github.com/repos/ethereum/execution-specs/commits/forks/bogota; Geth and Besu items report commit date 2026-10-27T17:40:55Z and matching shallow-clone HEAD |
| ethereum/EIPs | master | Geth item pins [d4c575521d99ec881a444ab3af604e684b5f0743](https://github.com/ethereum/EIPs/commit/d4c575521d99ec881a444ab3af604e684b5f0743), via https://api.github.com/repos/ethereum/EIPs/commits/master. Nethermind and Besu name master but supply no EIPs commit. |

The items cover EIP-2780, EIP-7976 and EIP-7981, including their cited interactions with other gas rules. All three report those EIPs as Last Call; the Geth item also reports a 2026-11-01 last-call deadline at its EIPs pin. These inputs do **not** establish the broader goal's complete Glamsterdam EIP roster from a meta EIP and consensus specs. This merge makes no claim to have completed that separate work or reviewed other clients.

All three inputs were present and nonempty. The supplied SHA-256 values matched the files read:

| Input | SHA-256 |
|---|---|
| `.imd/reads/artifacts/item-geth` | `fe41d436bf1da1644ecf20969de54568bbbba08ebef65f60099a441e7bacdf54` |
| `.imd/reads/artifacts/item-nethermind` | `f7decf169b52723a6b8ef9694b6fdcc8a0d9a986332f86015bb999e56b6f9d3a` |
| `.imd/reads/artifacts/item-besu` | `2ae79b5eb8590de8b65a2ba579808bd813dadb516daa26dd9fb12f6ac3b255a0` |

First-person passages in the preserved sections below are the item reviewers' statements. Their evidence, qualifications and non-candidate classifications are retained. Source URL inventories are omitted; pin/citation definitions and substantive source citations remain.

Citation definitions needed to resolve the original file#line tokens:

- Geth: `https://raw.githubusercontent.com/ethereum/go-ethereum/8817f99f92852f8ac53e596de6202dd9e3494065/<path>`
- Spec: `https://raw.githubusercontent.com/ethereum/execution-specs/7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b/src/ethereum/forks/amsterdam/<path>`
- Nethermind: `https://raw.githubusercontent.com/NethermindEth/nethermind/d48833af88ec4224c86afadd1c596e8f619c406b/src/Nethermind/<path>`

- `B/` = https://github.com/besu-eth/besu/blob/aa06c4f8dfc461e483d46c6a1ac72b5bfef8d945/
- `S/` = https://github.com/ethereum/execution-specs/blob/7f2f4c9bf6d73b09ecb8b24eb14d08bf0cf0247b/src/ethereum/forks/amsterdam/
- `G/` = https://github.com/ethereum/go-ethereum/blob/8817f99f92852f8ac53e596de6202dd9e3494065/

Besu paths abbreviated below:
- `AGC` = `evm/src/main/java/org/hyperledger/besu/evm/gascalculator/AmsterdamGasCalculator.java`
- `MTV` = `ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionValidator.java`
- `MTP` = `ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java`
- `TGA` = `ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/TransactionGasAccounting.java`

In the Nethermind extracts, NM means the Nethermind pin above, ES means the Amsterdam spec directory above, and GE means the Geth pin above. A bare Nethermind basename refers to the file identified in the item where available: `EthereumGasPolicy.cs` is under `src/Nethermind/Nethermind.Evm/GasPolicy/`, `IntrinsicGasCalculator.cs` under `src/Nethermind/Nethermind.Evm/`, `TransactionProcessor.cs` under `src/Nethermind/Nethermind.Evm/TransactionProcessing/`, and `GasCostOf.cs` / `Eip8038Constants.cs` under `src/Nethermind/Nethermind.Core/`. The item gives no full path for `BlockValidator.cs` and no line range for `CalculateBlockGas`; those citation gaps are retained, not reconstructed. Unqualified Geth line references in the Nethermind rules table refer to `core/state_transition.go` as in that item. Issue/PR numbers resolve within the repository named in each known-check paragraph.

## Candidates supplied

**Geth: 0; Nethermind: 0; Besu: 0.** No item supplied a candidate with six parts, so there are no `<client>-<n>` entries to copy or renumber. No rejected lead or known out-of-scope issue has been promoted to a candidate. The complete original candidate sections follow, including Geth's disproof evidence and Nethermind's cosmetic check-order note.

<a id="geth-candidates"></a>

### Geth — original §2, Candidates

**None.** I found no place where Geth's intrinsic gas, calldata floor, access-list charge, check order or floor settlement gives a different gas figure, state or block-validity result from the spec at the pins. Following the brief ("prefer no candidate to a weak one"), the near-misses I examined and rejected are listed in §4 with the reason for each.

How I tried to disprove the "no candidate" result:
1. **Line-by-line reading** of Geth `IntrinsicGas`, `intrinsicBaseGasEIP2780`, `FloorDataGas`, `execute`, `preCheck` and `settleGas` against spec `calculate_intrinsic_cost`, `validate_transaction`, `check_block_gas_capacity` and `settle_transaction_gas` (§3).
2. **Differential vector check, run locally.** This ran no node and no network. A throwaway Go test in a temporary copy of the pinned Geth clone (go1.25.4) called `core.IntrinsicGas` and `core.FloorDataGas` with Amsterdam rules on 3000 random transactions. The cases were:
   - create, self-transfer and call to another account;
   - value 0 or 1;
   - no access list, or 0–3 entries with 0–3 keys each;
   - 0–3 authorizations;
   - calldata from 0 to 70 000 bytes, about one-third zero bytes.

   I compared the outputs with a Python transcription of spec `transactions.py#L689-L798` and the `vm/gas.py` constants: **0 mismatches** in either the execution intrinsic or the floor. The harness was not delivered. Limitation: the Python side is my own transcription, not the EELS package (its dependencies were not installed).
3. **Public test results.** In the hive Glamsterdam `eels/consume-engine` run for Geth `v1.17.11-unstable-d01e869d-20261026` (file `1793010480-d551c775c4d248e574860df4df37a25e.json`, listed in `listing.jsonl`), every test case whose name contains these EIPs passed:

   | EIP | Passed | Failed |
   |---|---|---|
   | eip2780 | 292 | 0 |
   | eip7976 | 553 | 0 |
   | eip7981 | 194 | 0 |
   | eip7623 | 966 | 0 |
   | eip8038 | 274 | 0 |

   That run's only 2 failures are EIP-7928 BAL cross-index tests. The `consume-enginex` run's 50 failures are 4844/7918 BPO fork-transition tests plus the same 2 EIP-7928 tests. Caveat: hive tested `d01e869d` (2026-10-26), not exactly the pin `8817f99f`.

<a id="nethermind-candidates"></a>

### Nethermind — original Candidates

**None.** I found no case where Nethermind's intrinsic gas, floor gas, validity check or gas settlement differs from the spec at the pins above. The closest thing is the order of the validity checks (below). Rejection is the same either way, so I did not raise it as a candidate.

- Order of checks (not a candidate). NM `Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs#L1041-L1066` checks the EIP-8037 cap (`ExceedsCap`: execution > 16,777,216 or floor > cap) **before** checking `gas_limit < intrinsic` and `gas_limit < floor`. ES `transactions.py#L671-L684` checks the gas limit first, then the cap. Every one of these conditions makes the transaction invalid in both, so validity is the same. Only the error string can differ (for example, "intrinsic gas exceeds cap" rather than "insufficient intrinsic gas"). That could matter for exception mapping in tests. Severity: cosmetic.

<a id="besu-candidates"></a>

### Besu — original Candidates

None. Each topic in the brief was compared and found to match; see the table below. I ran the disproof the other way round: for each rule I looked for an input (a transaction shape, a boundary value, or the first Amsterdam block) on which Besu's arithmetic diverges from the spec. I found none.

## Cross-client comparison

Each cell uses the requested vocabulary. **agrees with spec** means the input supports the stated result at its pin, within the qualification in the rule column. **not checked** means that these inputs do not establish spec conformance for that client and rule; this also covers explicitly unverified leads and behavior for which the items identify no spec rule. It does not imply that no code was read. No cell is marked **differs (see &lt;client&gt;-&lt;n&gt;)**, because the inputs report no candidates.

Evidence links lead to verbatim rule tables and notes below. G1–G20, N1–N16 and B1–B21 mean source-table row numbers; N rows are counted in their original order. The table separates validity outcomes from check order, consensus accounting from RPC values, and ordinary settlement from the unresolved negative-state-gas case.

| Rule flagged or checked; source evidence | Geth | Nethermind | Besu |
|---|---|---|---|
| TX_BASE = 12000; TX_VALUE_COST = 6000 — [G1](#geth-rules), [N2](#nethermind-rules), [B1/B3](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Recipient charge: self 0; creation 12000; other calls 3000, including zero-value calls — [G2](#geth-rules), [N3](#nethermind-rules), [B2](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Value surcharge only for non-self, non-create calls with nonzero value; creation with value has no extra charge — [G3](#geth-rules), [N4](#nethermind-rules), [B3](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Self-transfer comparison uses the recovered sender in block processing — [G4](#geth-rules), [N15](#nethermind-rules), [B2](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Missing-sender provisional pricing is retried after sender recovery in block validation — [N15](#nethermind-rules) | not checked | agrees with spec | not checked |
| Standard calldata intrinsic cost: zero/nonzero bytes cost 4/16 — [G5](#geth-rules), [N5](#nethermind-rules), [B4](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Init-code charge: 2 times rounded-up 32-byte words, creation only, execution side only — [G6](#geth-rules), [N6](#nethermind-rules), [B5](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Access-list entry charge: 2900/address, 2000/key under EIP-8038, despite EIP-7981's older parameter table — [G7](#geth-rules), [N7](#nethermind-rules), [B6](#besu-rules), [Besu reference](#besu-reference) | agrees with spec | agrees with spec | agrees with spec |
| EIP-7981 surcharge on execution intrinsic: 80/128 tokens times 16 = 1280/address and 2048/key — [G8](#geth-rules), [N8](#nethermind-rules), [B7](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Same EIP-7981 surcharge on the floor — [G9](#geth-rules), [N8](#nethermind-rules), [B8](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| EIP-7976 calldata floor: 64 gas/byte, zero and nonzero alike — [G10](#geth-rules), [N9](#nethermind-rules), [B9](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Floor anchor includes recipient/value terms but excludes init-code words and authorizations — [G11](#geth-rules), [N6/N9](#nethermind-rules), [B10](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Per-authorization execution charge = 7816 — [G12](#geth-rules), [N10](#nethermind-rules), [B11](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| No intrinsic PER_EMPTY_ACCOUNT_COST or delegation refund on the Amsterdam authorization path — [B11](#besu-rules) | not checked | not checked | agrees with spec |
| Empty set-code authorization list or nil recipient is invalid — [G13](#geth-rules) | agrees with spec | not checked | not checked |
| Execution intrinsic must not exceed transaction gas — [G14](#geth-rules), [N11](#nethermind-rules), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Floor must not exceed transaction gas — [G14](#geth-rules), [N11](#nethermind-rules), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Intrinsic and floor each must not exceed 2^24 — [G14](#geth-rules), [N11](#nethermind-rules), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Transaction gas must not exceed 2^32−1 — [G14](#geth-rules), [N11](#nethermind-rules), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Equality at the intrinsic/floor/gas-cap validity boundaries is allowed — [G14](#geth-rules), [N11](#nethermind-rules), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Simulation-only execution-cap bypass does not change block validity — [G14](#geth-rules) | agrees with spec | not checked | not checked |
| Gas-limit versus intrinsic/floor-cap check order: same rejection outcome, potentially different error — [G14](#geth-rules), [Nethermind note](#nethermind-candidates), [B12](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Intrinsic/floor versus nonce/balance check order: same block-validity outcome, not identical control flow — [Geth rejected note](#geth-rejected), [B13](#besu-rules) | agrees with spec | not checked | agrees with spec |
| Block capacity: min(2^24, tx.gas) against execution room, tx.gas against state room — [G15](#geth-rules) | agrees with spec | not checked | not checked |
| Post-intrinsic execution allocation and reservoir split — [B14](#besu-rules) | not checked | not checked | agrees with spec |
| Refund capped at one fifth; floor applied after refund — [G16](#geth-rules), [N12](#nethermind-rules), [B15](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Self-destruct refund remains zero in the settlement path described — [B15](#besu-rules) | not checked | not checked | agrees with spec |
| Floor-equals-execution boundary returns the same max — [G17](#geth-rules), [N12](#nethermind-rules), [B16](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Block execution gas is pre-refund and floored; negative-state reachability is excluded here and listed separately — [G16](#geth-rules), [N13](#nethermind-rules), [B17](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| First Amsterdam block uses the block's fork rules — [G18](#geth-rules), [N16](#nethermind-rules), [B19](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Intrinsic memoization keyed by spec instance and self-transfer flag prevents cross-fork reuse — [N16](#nethermind-rules) | not checked | agrees with spec | not checked |
| Amsterdam switches on 2780/7976/7981/8038/8037 and leaves the EIP-8131 content-floor branch off — [N1 and disproof](#nethermind-rules) | not checked | agrees with spec | not checked |
| Pool and block paths reuse the checked intrinsic/floor formula; pool admission policy itself is not a spec rule — [G19](#geth-rules), [N14](#nethermind-rules), [B18](#besu-rules) | agrees with spec | agrees with spec | agrees with spec |
| Pool uses Osaka at the last pre-Amsterdam head: observed in Geth/Besu, no spec-defined admission rule — [Geth rejected note](#geth-rejected), [B18](#besu-rules) | not checked | not checked | not checked |
| Minimum-gas heuristics are consistent with the 12000 protocol minimum; no claim that the spec mandates those filters — [G20](#geth-rules), [B20](#besu-rules) | agrees with spec | not checked | agrees with spec |
| Overflow handling yields no reachable validity difference within protocol bounds — [Geth rejected note](#geth-rejected), [B21](#besu-rules) | agrees with spec | not checked | agrees with spec |
| Nil versus empty access/auth lists do not change charge; empty set-code auth is still rejected — [Geth rejected note](#geth-rejected) | agrees with spec | not checked | not checked |
| EIP-2780 floor prose: cold charge still applies to zero-value non-self calls in the spec code — [Geth prose note](#geth-rejected), [N3/N9](#nethermind-rules), [Besu reference](#besu-reference) | agrees with spec | agrees with spec | agrees with spec |
| EIP-7981 flat surcharge outside max is equivalent to adding it to both sides — [Geth prose note](#geth-rejected), [Nethermind prose note](#nethermind-rules), [Besu reference](#besu-reference) | agrees with spec | agrees with spec | agrees with spec |
| Geth RPC estimator treatment of caller gas 12000–20999: observed, RPC-only, not a consensus rule — [Geth rejected note](#geth-rejected) | not checked | not checked | not checked |
| RPC maxUsedGas/estimate floor placement: Besu known PR #11580; spec does not define the value — [Besu known-check](#besu-known) | not checked | not checked | not checked |
| BFT transactiongaslimit override and intrinsic cap: Besu known issue #11492, outside Ethereum Amsterdam scope — [Besu known-check](#besu-known) | not checked | not checked | not checked |
| Negative top-frame state gas: clamp in spec versus error in Geth/unclamped Besu accounting; reachability unverified, no candidate — [Geth lead](#geth-rejected), [Besu lead](#besu-pointer) | not checked | not checked | not checked |

The source reports agree on the checked consensus arithmetic; their coverage differs. The check-order observations concern different pairs of checks and do not conflict: Geth's note is about intrinsic versus nonce/balance, while Nethermind's is about the cap versus the transaction gas limit. Besu discusses both. The broad “match” statements on block settlement do not resolve the separate negative-state-gas lead. Source wording and that limitation are both preserved below.

## Known-check summary

| Client | Reported issue/PR result | Public-test evidence and limits |
|---|---|---|
| Geth | No candidate and no open issue found on the reviewed rules; minimum-gas fix #36020 was already merged at the pin. [Original known-check](#geth-known) | Earlier Hive build d01e869d: no failures attributed to eip2780/eip7976/eip7981/eip7623/eip8038. This is not a test of the exact source pin. [Counts and local disproof limits](#geth-candidates) |
| Nethermind | No candidate; issue matching the cosmetic check-order note was **not found**. Closed sender-recovery PR #14468 was identified. [Original known-check](#nethermind-known) | Hive 2.3.0-preview+a183d792: 239 failures / 44225 tests; failures were **not attributed** to these rules. Individual tracker failures were not inspected. This build differs from the source pin. |
| Besu | No candidate. Known open RPC-only floor PR [#11580](https://github.com/besu-eth/besu/pull/11580), and known open BFT-only cap issue [#11492](https://github.com/besu-eth/besu/issues/11492), remain non-candidates. [Original known-check](#besu-known) | Earlier develop builds bdb9e5c/fc46028: 9/44225 and 69/83258 failures; none reported in the five reviewed EIP directories. Trackers #3217/#3518 had no Besu entry; other tracker comments were unread. These are not tests of the exact source pin. |

No “known” candidate status is invented for a no-candidate result, and Nethermind's unclassified failures are not treated as passes. The two EIP-8037 leads have no established trigger or candidate-specific known-check. Complete item known-checks follow unchanged. Their statuses describe the source reviews' date, not a fresh search by this merge.

<a id="geth-known"></a>

### Geth — original §5, Known-check

GitHub search API (`api.github.com/search/issues`, issues and PRs, open and closed), `repo:ethereum/go-ethereum`:

| Query | Relevant hits (number, state) |
|---|---|
| `2780` | #35212 implement EIP-2780 (closed PR); #35318 EIP-2780 + EIP-8037 changes (closed PR); #35454 / #35456 update 2780 / 8038 parameters (closed PRs); #35467 miner EIP-2780 packing floor (closed PR); #35592 gasestimator plain transfer (closed PR); #35773 exclude txs if gas insufficient (closed PR); #35279 remaining spec fixes for glamsterdam (closed PR) |
| `7976` | #34748 implement eip-7976 (closed PR) |
| `7981` | #34755 implement eip-7981 (closed PR) |
| `calldata floor`, `"floor" amsterdam` | #35954 report EIP-8037 gas settlement in tracers (open PR); #33601 EIP-8037 (closed PR) |
| `intrinsic amsterdam` | #35838 eth_call execution gas capped at 2^24 after Amsterdam (closed issue) |
| `"access list" amsterdam` | only BAL / EIP-7928 items, none about the EIP-2930/7981 intrinsic charge |
| `"minimal gas"` | #36020 "eth/protocols/eth: fix minimal gas after amsterdam", closed and merged 2026-10-27T03:32:48Z (= the pin commit; already indexed) |

- execution-specs `"Test Release Tracker"`: #3217 `tests@v21.0.0` (Glamsterdam Testnet), open. Its EIP-2780 and EIP-7976 entries list only EIP-text wording PRs (ethereum/EIPs#11377, #11226), no client issues. I also saw #3518 `glamsterdam-devnet@v8.1.4` (closed) and #3889 `bogota-devnet@v2.0.0` (open).
- `https://hive.ethpandaops.io/glamsterdam/listing.jsonl`: the latest Geth runs (2026-10-26) show consume-engine 44223/44225, consume-enginex 83208/83258, consume-rlp 44159/44161 and execute 173/173. No failure falls in eip2780, eip7976, eip7981, eip7623 or eip8038 (§2).
- With no candidates, there is nothing to mark "known". The queries above found no open Geth issue on these rules.

The public Hive results cited by the Geth item are [consume-engine](https://hive.ethpandaops.io/glamsterdam/results/1793010480-d551c775c4d248e574860df4df37a25e.json) and [consume-enginex](https://hive.ethpandaops.io/glamsterdam/results/1793002245-b76d34132a39972f8bd764357b16c253.json), indexed in [the Glamsterdam listing](https://hive.ethpandaops.io/glamsterdam/listing.jsonl). These links identify the source of the preserved test claims, rather than a new test run.

<a id="nethermind-known"></a>

### Nethermind — original Known-check

- NethermindEth/nethermind searches for "2780", "7976", "7981", "intrinsic gas amsterdam" and "floor gas" (GitHub search API). Related closed PRs: #14468 (recover EIP-2780 senders in the block validator), #13929 and #12228 (EIP-8131 content floor, closed), #14944. None reports a mismatch with the spec. Result for the order-of-checks note: **not found**.
- execution-specs Test Release Tracker issues: #3889 `bogota-devnet@v2.0.0` (open), #3788 and #3787 (hegota, open). I did not inspect individual failures.
- hive.ethpandaops.io/glamsterdam/listing.jsonl: `eels/consume-engine` nethermind `2.3.0-preview+a183d792`, 44225 tests, 239 fails, 2026-10-26 (already indexed). I did not attribute those failures to the rules above.

The Nethermind item supplies the [Glamsterdam listing](https://hive.ethpandaops.io/glamsterdam/listing.jsonl), but no individual Hive result-file URL for its cited run.

<a id="besu-known"></a>

### Besu — original Known-check

- **besu-eth/besu issues/PRs** (GitHub search API, open and closed). Queries: `repo:besu-eth/besu 2780`, `7976`, `7981`, `intrinsic gas amsterdam`, `calldata floor`, `access list floor`. Relevant hits:
  - Implementation PRs, all closed:
    - https://github.com/besu-eth/besu/pull/10246, /10375 ("Add EIP-7976 to Amsterdam")
    - /10247, /10388 ("Add EIP-7981 to Amsterdam")
    - /10908 (EIP-2780/7702/8038 intrinsic gas)
    - /10925 (EIP-2780 fold transfer log into TX_VALUE_COST)
    - /10930 (EIP-3120/8037/8038 calldata floor)
    - /11140 (devnet-8 EIP-2780/8038 revisions)
    - /10594 (reject tx whose calldata floor exceeds the cap)
    - /11411 and /11414 (tx.gas cap at TX_MAX_TOTAL_GAS_LIMIT)
  - **Open PR https://github.com/besu-eth/besu/pull/11580** "Apply the calldata floor to the total gas used before refunds" (open, created 2026-10-13). It fixes the RPC-only `maxUsedGas`/estimate value, currently `max(execution, floor) + state` at `B/TGA#L103-L104`, which should be `max(execution + state, floor)`, as Geth's `peakUsed` computes (`G/core/state_transition.go#L1077-L1085`). The PR states that block accounting and receipts are unchanged. execution-specs does not define this RPC value. Status: **known (open PR)**; not consensus; not counted as a candidate.
  - Open issue https://github.com/besu-eth/besu/issues/11492: the BFT `transactiongaslimit` override drops the Amsterdam intrinsic cap of 2^24. It affects BFT/private chains only, not mainnet Amsterdam. Status: **known (open)**; outside this item's scope.
- **execution-specs "Test Release Tracker" issues.** Searched `repo:ethereum/execution-specs "Test Release Tracker" glamsterdam`:
  - https://github.com/ethereum/execution-specs/issues/3217 (`tests@v21.0.0`, Glamsterdam Testnet, open)
  - /3518, /3479, /3452, /3311 (`glamsterdam-devnet@v8.1.x`, closed)
  - /3034 (`glamsterdam-devnet@v7.0.0`, closed)

  Issues #3217 and #3518 (bodies and comments) mention no Besu entry. I did not read the other trackers' comments.
- **hive.ethpandaops.io/glamsterdam/listing.jsonl** (fetched 2026-10-27).
  - Latest Besu runs: `eels/consume-engine` (besu v26.10-develop-bdb9e5c, 2026-10-25): 44225 tests, 9 fails. `eels/consume-enginex` (fc46028, 2026-10-26): 83258 tests, 69 fails.
  - The failing tests are `test_unrecoverable_signature`, `test_reject_incorrect_two_dimensional_header` (EIP-8037 header rules), BPO-transition blob tests, and EIP-7918 reserve-price transitions. **None is in the eip2780/eip7976/eip7981/eip7623/eip8038 test directories.**
  - In the consume-engine run, all 292 eip2780, 553 eip7976, 194 eip7981, 966 eip7623 and 274 eip8038 test cases pass.
  - Caveat: those hive builds are at Besu develop `bdb9e5c`/`fc46028`, not at the pin `aa06c4f8`.
- Already indexed by the requester: none.
- Overall: no intrinsic/floor/access-list candidate, so no "known" mark is needed. The only floor-related open item (#11580) is RPC-only.

The public Hive result files cited by the Besu item are [consume-engine](https://hive.ethpandaops.io/glamsterdam/results/1793007262-bcaea78021015fd4b0776e606b920c4d.json) and [consume-enginex](https://hive.ethpandaops.io/glamsterdam/results/1793018005-fa5bfa67da513c8de132d620958d92dc.json), indexed in [the Glamsterdam listing](https://hive.ethpandaops.io/glamsterdam/listing.jsonl).

## Preserved supporting evidence

These sections keep the original file#line citations, quoted lines, rule tables and rejected leads. Original Geth §2, §3, §4 and §5 references point to its candidate/disproof, rules, rejected-note and known-check sections reproduced here; they do not refer to the merge's section order. No missing file range, test classification or reachability proof has been supplied by the merger.

<a id="geth-rules"></a>

### Geth — original §3, Rules checked and found correct

Spec = execution-specs at the pin. "Agrees" = Geth gives the same result as the spec.

| # | Rule (spec) | Spec location | Geth location at pin | Nethermind at pin | Result |
|---|---|---|---|---|---|
| 1 | `TX_BASE = 12000`, `TX_VALUE_COST = 6000` | `vm/gas.py#L143-L144` | `params/protocol_params.go#L111-L112` (`TxBaseCost2780 = 12000`, `TxValueCost2780 = 6000`) | `Nethermind.Core/GasCostOf.cs#L100-L101` | agrees |
| 2 | Recipient term: self-transfer 0; create `CREATE_ACCESS` (=9000+3000); otherwise `COLD_ACCOUNT_ACCESS` 3000 | `transactions.py#L739-L747`, `vm/gas.py#L77,L85,L90` | `core/state_transition.go#L163-L184`; `params/protocol_params.go#L115,L117,L123` | `Nethermind.Evm/GasPolicy/EthereumGasPolicy.cs#L779-L780,L845-L850,L865-L880` | agrees |
| 3 | Value term only for a non-self, non-create call with value > 0 (**creation with value pays no `TX_VALUE_COST`**) | `transactions.py#L746-L747` | `core/state_transition.go#L187-L192` | `EthereumGasPolicy.cs#L869-L877` | agrees |
| 4 | Self-transfer test is `tx.to == sender` (recovered sender) | `transactions.py#L737` | `core/state_transition.go#L166` (`*to == from`); `from` is `msg.From` (L729) and recovered `from` in the txpool (`core/txpool/validation.go#L120,L135`) | `EthereumGasPolicy.cs#L779-L780` | agrees |
| 5 | Calldata standard cost `tokens*4` with tokens = zero + 4·nonzero (= 4/16 per byte) | `transactions.py#L732-L734,L801-L811` | `core/state_transition.go#L93-L112` (`TxDataZeroGas=4`, `TxDataNonZeroGasEIP2028=16`, `params/protocol_params.go#L39,L93`) | `IntrinsicGasCalculator.cs#L46-L51`, `EthereumGasPolicy.cs#L853-L854` | agrees |
| 6 | Init-code word cost `2*ceil(len/32)` on create only | `transactions.py#L741`, `vm/gas.py#L864-L883` | `core/state_transition.go#L114-L120` (`InitCodeWordGas=2`, `params/protocol_params.go#L46`) | `GasCostOf.cs#L59` (via `GetBaseDataCost`) | agrees |
| 7 | Access-list entry cost 2900/address, 2000/key (`COLD-WARM`, EIP-8038) | `vm/gas.py#L147-L152` | `core/state_transition.go#L128-L141`; `params/protocol_params.go#L124-L125` | `IntrinsicGasCalculator.cs#L59-L74`, `Nethermind.Core/Eip8038Constants.cs#L10` | agrees |
| 8 | EIP-7981 surcharge: 80 tokens/address, 128/key, ×16 = 1280/2048, added to the **execution** intrinsic | `transactions.py#L69,L77,L750-L766,L789-L791` | `core/state_transition.go#L144-L157` (20·16·4 = 1280; 32·16·4 = 2048) | `IntrinsicGasCalculator.cs#L54-L57,L74` | agrees |
| 9 | Same surcharge also in the **floor** (both sides of the max) | `transactions.py#L781-L786` | `core/state_transition.go#L212-L225` (tokens += 80·addr + 128·key) then `floorBase + tokens*16` (L251-L255) | `IntrinsicGasCalculator.cs#L164` | agrees |
| 10 | EIP-7976 floor: `len(data)*4` tokens at 16 = 64/byte, zero and nonzero alike | `vm/gas.py#L145-L146`, `transactions.py#L775,L784` | `core/state_transition.go#L202-L210` (`TxCostFloorPerToken7976=16`, `params/protocol_params.go#L96`) | `IntrinsicGasCalculator.cs#L105-L106,L164` | agrees |
| 11 | Floor base = `TX_BASE + recipient term (+value)`; init-code and auth excluded | `transactions.py#L779-L786` | `core/state_transition.go#L246-L249` (`intrinsicBaseGasEIP2780`) | `EthereumGasPolicy.cs#L798` (`baseCost + createCost + eip2780ExtraGas`; init code is in `DataCost`, not `createCost`) | agrees |
| 12 | EIP-7702: per-auth `EXECUTION_PER_AUTH_BASE_COST` = 101·16+3000+3000+200 = 7816 | `vm/gas.py#L157-L162`, `transactions.py#L768-L772` | `core/state_transition.go#L85-L91`; `params/protocol_params.go#L108` (`7816`) | `IntrinsicGasCalculator.cs#L81-L98`, `Eip8038Constants.cs#L26` | agrees |
| 13 | Set-code tx with empty auth list or `to = nil` is invalid | `transactions.py#L664-L670` | `core/state_transition.go#L670-L681` | — | agrees |
| 14 | Validity: `intrinsic > gas` → invalid; `floor > gas` → invalid; `intrinsic > TX_MAX_GAS_LIMIT` or `floor > TX_MAX_GAS_LIMIT` → invalid; `gas > 2^32-1` → invalid | `transactions.py#L640-L641,L672-L684`; `vm/gas.py#L153-L154` | `core/state_transition.go#L729-L754` (intrinsic, floor, `max(intrinsic,floor) > MaxTxGas`); `#L590-L594` (`MaxTxTotalGas = 1<<32-1`, `params/protocol_params.go#L31-L32`) | `Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs#L1040-L1064` | agrees (the `skipExecutionGasCap` bypass, L321-L327, is a simulation-only `Message` flag) |
| 15 | Block capacity check: `min(TX_MAX_GAS_LIMIT, tx.gas)` vs execution room, `tx.gas` vs state room | `vm/gas.py#L1038-L1086` | `core/state_transition.go#L689-L696`, `core/gaspool.go#L64-L72` | — | agrees |
| 16 | Refund capped at `before_refund/5`, **floor applied after refund**: `gas_used = max(after_refund, floor)`; block execution gas = `max(before_refund - state_gas, floor)` | `vm/gas.py#L1163-L1228` | `core/state_transition.go#L1066-L1092`, `#L1238-L1249` | `TransactionProcessor.cs#L1955-L1978` (`Math.Max(operationGas, floorGasLong)`) | agrees |
| 17 | Boundary where floor == execution cost: no adjustment (`max` of equals) | `vm/gas.py#L1214` | `core/state_transition.go#L1078` (strict `<`, so equal values leave gasUsed unchanged, the same result) | `Math.Max` | agrees |
| 18 | Fork activation by timestamp at the first Amsterdam block | (fork scheduling) | `params/config.go#L742-L744`, `#L1308` (`IsAmsterdam: isMerge && c.IsAmsterdam(num, timestamp)`) | `Nethermind.Specs/Forks/25_Amsterdam.cs#L14-L16,L25` | agrees |
| 19 | txpool and block processing use one formula | — | the txpool calls the same `core.IntrinsicGas` and `core.FloorDataGas`, plus the same `max(...) > MaxTxGas` cap (`core/txpool/validation.go#L135-L157`); t8n does too (`cmd/evm/internal/t8ntool/transaction.go#L143,L157`) | — | agrees (see the fork-boundary note in §4) |
| 20 | Protocol minimum-gas filters after Amsterdam use 12000 | — | `miner/worker.go#L466-L471`; `eth/protocols/eth/peer.go#L638-L643` (PR #36020, the pin commit itself) | — | consistent: per-tx gas used ≥ `TX_BASE` = 12000 |

<a id="geth-rejected"></a>

### Geth — original §4, Rejected near-misses (not candidates)

- **Check order (cosmetic only).** Spec `check_transaction` calls `validate_transaction` (intrinsic and floor) before the nonce and balance checks (`fork.py#L538-L571`). Geth runs `preCheck` first (nonce, caps, fees, `buyGas`; `core/state_transition.go#L573-L698`) and the intrinsic check after it (L729-L754). Any transaction failing either is invalid in both, so a block containing it is rejected by both. Only the reported error class can differ when a transaction fails several checks. hive EEST exception matching passes for these EIPs (§2), so this was not escalated.
- **`accessList != nil` vs spec `has_access_list(tx)`.** An empty or absent list contributes 0 either way, so the result is identical. The same holds for `authList != nil`: an empty set-code list is rejected (#13).
- **uint64 overflow errors** (`ErrGasUintOverflow`) versus the spec's unbounded `Uint`. These are unreachable, because any value that large far exceeds `TX_MAX_TOTAL_GAS_LIMIT` and is invalid in both.
- **txpool at the fork boundary (not consensus).** `ValidateTransaction` derives `rules` from the pool's current head (`core/txpool/validation.go#L74`, called with `pool.currentHead.Load()` at `core/txpool/legacypool/legacypool.go#L561`). Until the first Amsterdam block is the head, the pool applies Osaka pricing. Two effects follow:
  - a 12000–20999-gas self-transfer is refused;
  - an access-list transaction priced for Osaka (2400/1900, no surcharge) can be admitted although it is below the Amsterdam intrinsic gas.

  The block builder re-executes under Amsterdam rules and skips such a transaction, so no invalid block results. This is the usual Geth fork-transition pool behaviour, not a spec rule.
- **Gas estimator (RPC only, not consensus).** `eth/gasestimator/gasestimator.go#L61` still treats a caller-supplied gas below 21000 as "unset" (`call.GasLimit >= params.TxGas`). After Amsterdam a 12000-gas self-transfer is valid, so a cap between 12000 and 20999 is ignored as the upper bound. L127 runs the plain-transfer short-circuit at 21000 and falls back to binary search on failure. This affects RPC behaviour only.
- **EIP prose vs spec code (not a Geth issue).**
  - EIP-2780's EIP-7623 paragraph says the floor base adds "`COLD_ACCOUNT_ACCESS` and `TX_VALUE_COST` for a value transfer to a different account". This could be read as excluding `COLD_ACCOUNT_ACCESS` for a zero-value call, but its reference-cases table and the spec code (`transactions.py#L742-L747,L779`) charge it on every non-self call. Geth follows the code.
  - EIP-7981 prose says "flat surcharge … outside the max". The spec adds it to both sides of the max (`transactions.py#L762-L766`), which is numerically identical. Geth follows the code.
- **Out of scope, for the EIP-8037 item, not assessed.** Spec `settle_transaction_gas` clamps a negative net state gas to 0 (`vm/gas.py#L1216`, docstring: "refunds can drive it negative"). Geth instead returns an error when the top-frame `UsedStateGas < 0` (`core/state_transition.go#L1047-L1049`), which makes the transaction invalid. Whether net-negative top-frame state gas is reachable in Geth was not examined. This is a lead for the state-gas reviewer, not a candidate here.

<a id="nethermind-rules"></a>

### Nethermind — original Rules checked and found correct; disproof and prose notes

| Rule | Spec (ES unless stated) | Nethermind (NM) | Geth (GE) |
|---|---|---|---|
| Amsterdam turns on 2780/7976/7981/8038/8037; 8131 stays off | — | `src/Nethermind/Nethermind.Specs/Forks/25_Amsterdam.cs#L9-L27` | — |
| TX_BASE 12000, TX_VALUE_COST 6000 | `vm/gas.py#L143-L144` | `src/Nethermind/Nethermind.Core/GasCostOf.cs#L100-L101` | `core/state_transition.go#L172,L191` |
| Recipient term: cold 3000 for a non-self call; CREATE_ACCESS 12000 (9000+3000) for create; nothing for self-transfer | `transactions.py#L736-L747`, `vm/gas.py#L76-L90` | `src/Nethermind/Nethermind.Evm/GasPolicy/EthereumGasPolicy.cs#L779-L780,L845-L850,L865-L880`; `src/Nethermind/Nethermind.Core/Eip8038Constants.cs#L15-L23` | `core/state_transition.go#L163-L194` (same) |
| Value term only on a non-create, non-self transfer with value > 0; a create with value pays no TX_VALUE_COST | `transactions.py#L741-L747` | `EthereumGasPolicy.cs#L870-L878` | `core/state_transition.go#L187-L192` |
| Calldata standard cost: tokens (zero=1, nonzero=4) × 4 | `transactions.py#L732-L734,L801-L810` | `IntrinsicGasCalculator.cs#L46-L51`, `EthereumGasPolicy.cs#L853-L854` | `#L93-L112` (16/4 per byte) |
| Init code: 2 per 32-byte word, rounded up, execution side only (not in floor) | `transactions.py#L741-L743,L779-L797`, `vm/gas.py#L864` | `src/Nethermind/Nethermind.Evm/ReleaseSpecExtensions.cs#L20-L23`; it is in `executionGas` but not in `floorBase` at `EthereumGasPolicy.cs#L792-L798` | `#L114-L119`; floor uses `intrinsicBaseGasEIP2780` only (`#L247-L249`) |
| Access-list entry cost under EIP-8038: 2900 per address, 2000 per key | `vm/gas.py#L147-L152` | `Eip8038Constants.cs#L10-L25`, `IntrinsicGasCalculator.cs#L69-L74` | `#L127-L140` |
| EIP-7981 surcharge: 80 tokens per address, 128 per key, ×16 (1280/2048), added to **both** execution and floor | `transactions.py#L749-L766,L782-L795` | tokens `IntrinsicGasCalculator.cs#L54-L57` (20×4, 32×4); execution side `#L74`; floor side `#L164` | execution `#L143-L157`; floor `#L211-L226` |
| EIP-7976 floor: len(data)×4 tokens ×16; floor base = TX_BASE + recipient + value | `transactions.py#L775-L786` | `IntrinsicGasCalculator.cs#L105-L106,L160-L164`; `EthereumGasPolicy.cs#L798` | `#L197-L255` |
| EIP-7702 per-auth execution cost 101×16+3000+3000+2×100 = 7816 | `vm/gas.py#L157-L162` | `IntrinsicGasCalculator.cs#L94-L98`, `Eip8038Constants.cs#L26-L29` | `#L85-L88` |
| Validity: gas ≥ intrinsic, gas ≥ floor, both ≤ TX_MAX_GAS_LIMIT, gas ≤ TX_MAX_TOTAL_GAS_LIMIT | `transactions.py#L640-L641,L671-L684` | `TransactionProcessor.cs#L1033-L1066` | `#L592-L595,L690-L695` |
| Floor applied after the refund cap; boundary where floor equals execution resolves to max() | `vm/gas.py#L1211-L1214` | `TransactionProcessor.cs#L1938-L1976` (`spentGasAfterFloor = Math.Max(operationGas, floorGasLong)`) | — |
| Block gas (EIP-7778) is pre-refund, floored | `vm/gas.py#L1216-L1222` | `TransactionProcessor.cs` `CalculateBlockGas` (after `Refund`) | — |
| Txpool and block validation use the same formula | — | `src/Nethermind/Nethermind.Consensus/Validators/TxValidator.cs#L35-L87` (IntrinsicGasTxValidator); `src/Nethermind/Nethermind.TxPool/Filters/MalformedTxFilter.cs#L30-L41,L87-L93`; `BlockValidator.cs#L341-L361` | — |
| Self-transfer detection when the sender has not been recovered yet | — | `EthereumGasPolicy.cs#L779-L780`. A missing sender is priced as non-self, the higher price, so a false reject is possible but not a false accept. The block validator recovers the sender and retries (`BlockValidator.cs#L351-L361`); the processor recovers it before computing intrinsic gas (`TransactionProcessor.cs#L296-L297`). | — |
| First Amsterdam block | — | Every term is gated on `IsEip2780/7976/7981/8038Enabled` of the block's spec. The memo is keyed on the spec instance and the self-transfer flag (`EthereumGasPolicy.cs#L756-L768`), so a pre-fork value is not reused across the fork. | — |

**Disproof attempts.** I recomputed each constant by hand: 3000+9000, 3000−100, 2100−100, 20×4×16=1280, 32×4×16=2048, and 101×16+3000+3000+200=7816. I checked that init code is not in the floor base in either ES or NM. I checked that a create with value gets no TX_VALUE_COST in ES, NM and GE. I checked that EIP-8131 (content floor) is off in Amsterdam, so the `IsEip8131Enabled` branch at `IntrinsicGasCalculator.cs#L163` does not apply.

**EIP prose against spec.** EIP-7981 says "added as a flat surcharge to the gas used calculation" (https://eips.ethereum.org/EIPS/eip-7981). ES, NM and GE all add it to both intrinsic and floor, which gives the same numbers.

<a id="besu-reference"></a>

### Besu — original Reference formula (execution-specs, pinned)

`S/transactions.py#L689-L798` (`calculate_intrinsic_cost`) defines both values:
- **Execution side:** `TX_BASE + recipient_execution_gas + init_code_gas + data_cost + access_list_cost + access_list_data_cost + auth_cost`.
- **Floor side:** `TX_BASE + recipient_execution_gas + len(data)*4*16 + access_list_data_cost`.

Each term is defined as follows:
- `recipient_execution_gas`:
  - `CREATE_ACCESS` (12000) for a creation;
  - `0` for a self-transfer (`tx.to == sender`);
  - otherwise `COLD_ACCOUNT_ACCESS` (3000), plus `TX_VALUE_COST` (6000) if `tx.value > 0`.
- `access_list_data_cost = (80·addresses + 128·keys) · 16`. It is added to both sides: "Charge the access list data surcharge on both sides of the gas-used maximum" (`S/transactions.py#L762-L766`).
- Constants (`S/vm/gas.py`):
  - `TX_BASE` 12000 and `TX_VALUE_COST` 6000 (L143-L144);
  - `TX_DATA_TOKEN_STANDARD` 4 and `TX_DATA_TOKEN_FLOOR` 16 (L145-L146);
  - `TX_ACCESS_LIST_ADDRESS = COLD_ACCOUNT_ACCESS − WARM_ACCESS` = 2900 and `TX_ACCESS_LIST_STORAGE_KEY = COLD_STORAGE_ACCESS − WARM_ACCESS` = 2000 (L147-L152);
  - `EXECUTION_PER_AUTH_BASE_COST = 101·16 + 3000 + 3000 + 2·100` = 7816 (L157-L163);
  - `init_code_cost = 2·ceil32(len)/32` (L864-L882).
- Floor-token constants: `ACCESS_LIST_ADDRESS_FLOOR_TOKENS = 80` and `ACCESS_LIST_STORAGE_KEY_FLOOR_TOKENS = 128` (`S/transactions.py#L69-L77`).

Validity (`S/transactions.py#L588-L687`, `validate_transaction`): the transaction is invalid if any of these holds:
- `tx.gas > TX_MAX_TOTAL_GAS_LIMIT` (2^32−1);
- `intrinsic.execution > tx.gas`;
- `calldata_floor > tx.gas`;
- `intrinsic.execution > TX_MAX_GAS_LIMIT` (2^24);
- `calldata_floor > TX_MAX_GAS_LIMIT`.

All of these are strict `>`, so equality is valid.

Settlement (`S/vm/gas.py#L1163-L1220`):
```
gas_refund = min(gas_used_before_refund // 5, refund_counter)
gas_used = max(gas_used_after_refund, calldata_floor)
execution_gas_used = max(gas_used_before_refund − max(0, state_gas_used), calldata_floor)
```
`process_transaction` calls this function (`S/fork.py#L1056-L1063`).

How the EIP texts relate to the spec:
- **EIP-2780.** The intrinsic decomposition and the floor anchor ("that base term is replaced by the transaction's decomposed base — TX_BASE_COST plus the applicable recipient and value primitives … Per-authorization charges and initcode word charges are excluded from this base") agree with the spec.
- **EIP-7976.** "floor_tokens_in_calldata = (zero_bytes_in_calldata + nonzero_bytes_in_calldata) * 4" and "the floor cost is 64 gas per calldata byte".
- **EIP-7981.** The prose says "The access list data cost is added as a flat surcharge to the gas used calculation", with `access_list_data_cost = 64 * access_list_bytes` (1280 per address, 2048 per key). Adding a constant outside `max()` is algebraically the same as adding it to both arguments, which is what the spec does. So the "flat surcharge" prose and the "both sides" spec are numerically identical.
- **EIP-7981 parameter table.** It still lists `ACCESS_LIST_ADDRESS_COST` 2400 / `ACCESS_LIST_STORAGE_KEY_COST` 1900 (EIP-2930 values). The spec and every client reviewed here use the EIP-8038 values 2900/2000.

<a id="besu-rules"></a>

### Besu — original Rules checked and found correct; worked values

| # | Rule (spec) | Besu | Geth | Verdict |
|---|---|---|---|---|
| 1 | `TX_BASE` = 12000 replaces 21000 (`S/vm/gas.py#L143`) | `B/AGC#L113`, used at `B/AGC#L214-L218` and `B/AGC#L239` | `TxBaseCost2780 = 12000` `G/params/protocol_params.go#L111`, `G/core/state_transition.go#L172` | match |
| 2 | Recipient: creation → `CREATE_ACCESS` 12000; self-transfer → 0; otherwise → `COLD_ACCOUNT_ACCESS` 3000 (`S/transactions.py#L736-L747`) | `B/AGC#L247-L263`; `CREATE_ACCESS = ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS` at `B/AGC#L102`; self-transfer test `to == getSender()` at `B/AGC#L266-L271` | `G/core/state_transition.go#L163-L184` | match |
| 3 | `TX_VALUE_COST` 6000 only for a non-self, non-create call with value > 0. Creation with value pays nothing extra (`S/transactions.py#L744-L747`; EIP-2780 "if non-zero and contract creation, there are no charges") | `B/AGC#L125`, `B/AGC#L248-L262` (creation returns `CREATE_ACCESS` regardless of value; self-transfer returns 0) | `G/core/state_transition.go#L186-L192` | match |
| 4 | Calldata execution cost: tokens = zero + 4·nonzero, times 4 (`S/transactions.py#L732-L734`, `#L801-L810`) | `B/AGC#L226-L231` (zero count from `Transaction.getPayloadZeroBytes`, `B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java#L424-L426`) | `G/core/state_transition.go#L93-L112` (4/16 per byte) | match |
| 5 | Init-code word cost `2·ceil(len/32)` for creations, execution side only, not in the floor anchor (`S/transactions.py#L741-L743`, `#L779-L786`; `S/vm/gas.py#L864-L882`) | `B/AGC#L137`, `B/AGC#L233-L237`, `B/AGC#L273-L276` | `G/core/state_transition.go#L114-L120` | match |
| 6 | Access-list per-entry cost 2900/2000 (EIP-8038; `S/vm/gas.py#L147-L152`) | `B/AGC#L80-L84`, `B/AGC#L199-L212` | `G/params/protocol_params.go#L124-L125`, `G/core/state_transition.go#L127-L141` | match |
| 7 | EIP-7981 access-list data charge, 80/128 tokens × 16 = 1280/2048, on the execution side (`S/transactions.py#L749-L766`, `#L794`) | Added per entry inside `accessListGasCost`: `B/AGC#L55-L63`, `B/AGC#L206-L211` | `G/core/state_transition.go#L143-L157` | match |
| 8 | Same EIP-7981 charge on the floor side (`S/transactions.py#L782-L786`) | `B/AGC#L187-L196` and `B/AGC#L278-L285`: (20·addr + 32·keys) bytes × 64 = (80·addr + 128·keys) × 16 | `G/core/state_transition.go#L212-L225` (20·4 and 32·4 tokens × 16) | match |
| 9 | EIP-7976 floor: every calldata byte = 4 tokens × 16 = 64 gas (`S/transactions.py#L774-L775`, `#L782-L786`) | `B/AGC#L51-L52`, `B/AGC#L187`, `B/AGC#L194-L196` | `G/core/state_transition.go#L202-L211`, `#L251-L255` | match |
| 10 | Floor anchored on `TX_BASE + recipient_execution_gas` (includes `TX_VALUE_COST`; excludes init-code and auth) (`S/transactions.py#L777-L786`) | `B/AGC#L190-L193` (same helper `baseRecipientExecutionGas` as the intrinsic) | `G/core/state_transition.go#L243-L249` | match |
| 11 | EIP-7702 intrinsic: `EXECUTION_PER_AUTH_BASE_COST` 7816 × authorizations, with no intrinsic `PER_EMPTY_ACCOUNT_COST` and no refund (`S/transactions.py#L768-L772`) | `B/AGC#L133-L134`, `B/AGC#L399-L405`; summed via `B/evm/src/main/java/org/hyperledger/besu/evm/gascalculator/GasCalculator.java#L603-L607` and `B/MTV#L255-L262`; Amsterdam path sets no delegation refund (`B/MTP#L310`, `#L326-L330`; `codeDelegationRefund` is assigned only in the non-state-gas branch, `#L343-L345`) | `ExecutionPerAuthBaseCost = 7816` `G/params/protocol_params.go#L108`, `G/core/state_transition.go#L85-L88` | match |
| 12 | Validity checks: `intrinsic > gas`, `floor > gas`, `intrinsic > 2^24`, `floor > 2^24`, `gas > 2^32−1` (strict `>`) (`S/transactions.py#L640-L641`, `#L671-L685`) | `max(intrinsic, floor)` against the 2^24 cap at `B/MTV#L255-L273` and against `tx.gas` at `#L275-L281`, both via `compareUnsigned(...) > 0`; `tx.gas` against 4,294,967,295 at `B/MTV#L112-L121` with `B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AmsterdamTargetingGasLimitCalculator.java#L33` and `#L54-L57` (2^24 = `EIP_7825_TRANSACTION_GAS_LIMIT_CAP`, `OsakaTargetingGasLimitCalculator.java#L37`), wired for Amsterdam at `B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java#L1169-L1183` | `G/core/state_transition.go#L733-L753` | match. The checks run in a different order, but every failing check makes the transaction invalid, so the outcome is the same. Equality is valid in all three implementations. |
| 13 | Intrinsic checked before balance/nonce (`S/fork.py#L539` before `check_nonce` and the balance check) | `validate` (intrinsic/floor) at `B/MTP#L214-L226` comes before `validateForSender` at `#L232-L238`; the intrinsic is re-checked at `#L288-L303` | `G/core/state_transition.go#L733-L747` | match (block validity is the same either way) |
| 14 | Gas split after intrinsic: `execution = min(2^24 − intrinsic, gas − intrinsic)`, remainder to the reservoir (`S/vm/gas.py#L1105-L1137`) | `B/MTP#L354-L371` | n/a | match |
| 15 | Refund cap 1/5 of pre-refund usage (execution + state); floor applied **after** the refund: `max(after_refund, floor)` (`S/vm/gas.py#L1210-L1214`) | `B/AGC#L412-L435` (`totalConsumed/5`, `Math.max(gasUsed, floorCost)`); quotient 5 at `B/evm/src/main/java/org/hyperledger/besu/evm/gascalculator/LondonGasCalculator.java#L30`, `#L96-L98`; self-destruct refund 0 at `#L48-L50`; receipt/sender gas at `B/TGA#L105` | `G/core/state_transition.go#L1066-L1085` | match |
| 16 | Boundary where floor = execution cost: `max()` returns either; no strict/non-strict divergence (`S/vm/gas.py#L1214`, `#L1217-L1222`) | `B/AGC#L434`, `B/TGA#L103` | `G/core/state_transition.go#L1066`, `#L1078` (`gasUsed < floor`, so equality leaves it unchanged) | match |
| 17 | Block execution-gas dimension carries the floor: `max(pre_refund − state, floor)` (`S/vm/gas.py#L1216-L1222`) | `B/TGA#L91-L106`, accumulated at `B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java#L304-L307` | `G/core/state_transition.go#L1066` | match (see the pointer at the end on the `max(0, state)` clamp) |
| 18 | One formula for the txpool and block validation | The txpool calls the same `MainnetTransactionValidator.validate` (`B/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/transactions/TransactionPool.java#L519-L528`) with the same `GasCalculator`. The spec is selected from the **chain head** (`#L476-L481`), so on the last pre-Amsterdam head the pool still applies Osaka rules. Block import/building re-validates with the block's own spec (`B/MTP#L214-L226`) | Geth's pool also uses head rules: `G/core/txpool/validation.go#L74`, same `IntrinsicGas`/`FloorDataGas` at `#L135-L156` | not a spec rule; Besu and Geth behave the same. At most a transient pool-admission difference at the fork boundary, with no block-validity effect. |
| 19 | First Amsterdam block | Amsterdam milestone wiring selects `AmsterdamGasCalculator` and `AmsterdamTargetingGasLimitCalculator` per block header (`B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java#L1169-L1183`); every intrinsic and floor term is fork-local, with no parent-dependent input | `rules.IsAmsterdam` throughout `G/core/state_transition.go#L72-L256` | match |
| 20 | Protocol minimum-gas filters | Block builder "block full" threshold is `getMinimumTransactionCost()` = 12000 in Amsterdam (`B/ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/txselection/selectors/BlockSizeTransactionSelector.java#L148-L153`); `eth_estimateGas` lower bound uses the same value (`B/ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/AbstractEstimateGas.java#L115`, `#L153`). No hard-coded 21000 found in the core/eth/api/blockcreation main sources (grep for `21_?000`) | n/a | heuristics only; consistent with 12000 |
| 21 | Overflow | Products use `clampedAdd`/`clampedMultiply`, or are bounded by the maximum init-code size and RLP size (`B/AGC#L187-L196`, `#L206-L211`, `#L230-L239`) | explicit overflow errors at `G/core/state_transition.go#L104-L156`, `#L207-L253` | no reachable difference |

Worked values that are the same in Besu, the spec and Geth (from the formulas above):
- Self-transfer: 12000.
- Zero-value call: 15000.
- Value transfer: 21000.
- Creation with or without value: 24000 + 2·words + calldata.
- Floor of a value transfer with 100 calldata bytes: 21000 + 6400.
- An access list of 1 address and 1 key adds 2900 + 2000 + 1280 + 2048 to the intrinsic, and 1280 + 2048 to the floor.

<a id="besu-pointer"></a>

### Besu — original Pointer outside this item's scope (EIP-8037, not verified)

The spec clamps state gas before the block execution dimension: "the state gas used (clamped to zero, since refunds can drive it negative)", `settled_state_gas_used = StateGas(Uint(max(0, state_gas_used)))` (`S/vm/gas.py#L1216-L1222`).
- **Besu** uses the unclamped `stateGasUsed()` in `B/TGA#L92-L106` (`executionGas = consumedGas − stateGas`) and adds it unclamped to `cumulativeStateGasUsed` (`B/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java#L312`). `stateGasUsed` can be decremented by `refundRolledBackStateGas` (`B/MTP#L835`).
- **Geth** returns an error when the top-frame state gas is negative (`G/core/state_transition.go#L1047-L1049`).

If the top-frame state gas could end up negative, the three implementations would differ. I did not establish whether it can be negative in any of them; that belongs to the EIP-8037 reviewer. I report no candidate for it here.