When `validate_gas_used` fails, log per-tx breakdown (status, gas_used,
regular vs state, gas_spent, gas_refunded) plus block-level sums. Lets
divergent tx + dimension be located without re-running with extra tracing.

Adds `TxGasBreakdown` and `TxStatus` to `BlockExecutionResult`, populated by
the three levm execute paths (sequential `execute_block`, sequential
`execute_block_pipeline` body, parallel `execute_block_parallel`). L2
producer/committer paths leave the field empty; the diagnostic falls back to
a one-liner there.

Cost is one Vec<TxGasBreakdown> push per tx (~80 bytes). No formatting or
log emission unless the mismatch fires.

- bump COST_PER_STATE_BYTE 1174 → 1530 and byte counts
  (NEW_ACCOUNT 112→120, STORAGE_SET 32→64, AUTH_TOTAL 135→143)
- split same-tx selfdestruct refund: for the tx-created top-level
  target, route the NEW_ACCOUNT portion through the state_refund
  channel (block-accounted only, no reservoir credit, no execution
  clamp); non-account portion keeps the existing reservoir+absorbed
  clamped path

Pin every Amsterdam fixture site to `tests-bal@v7.0.0` (execution-specs
`devnets/bal/7`), the bal-devnet-7 fixture release published 2026-05-11.
Mirrored on execution-spec-tests as `bal@v7.0.0`.

Sites updated:
- tooling/ef_tests/blockchain/.fixtures_url_amsterdam
- tooling/ef_tests/state/.fixtures_url_amsterdam
- .github/config/hive/amsterdam.yaml (eels_commit e87390b6 → bcc2a876)
- Makefile (AMSTERDAM_FIXTURES_BRANCH: devnets/snobal/6 → devnets/bal/7)
- tooling/ef_tests/blockchain/Makefile (stale comment ref)

The bal-7 release contains parameter recalibration (CPSB 1174→1530,
NEW_ACCOUNT 112→120, STORAGE_SET 32→64) — already implemented on this
branch — plus the bug-fix set from execution-specs#2823 (tx-CREATE
halt/revert intrinsic refund, isolated 0→x→0 SSTORE refund,
CREATE-collision regular gas) and the SYSTEM_CALL_GAS_LIMIT raise,
which are the remaining bal-7 work items.

Per execution-specs commit 7b3e8016 ("eip-8037 system transaction gas
state reservoir"): system transactions now receive an extra state-gas
reservoir of `STATE_BYTES_PER_STORAGE_SET × cost_per_state_byte ×
SYSTEM_MAX_SSTORES_PER_CALL` on top of `SYS_CALL_GAS_LIMIT (30M)`. With
the bal-devnet-7 constants (STORAGE_SET=64, CPSB=1530, SSTORES=16) the
extra is 1,566,720 gas — enough to absorb 16 cold SSTORE state-gas
charges without spilling into the 30M regular budget.

The reservoir is allocated ADDITIVELY (not pre-consumed from
gas_remaining): system contracts (EIP-2935, EIP-4788, EIP-7002,
EIP-7251) get the full 30M regular budget plus the state-gas reservoir,
so state-gas growth alone cannot OOG them.

Wired by overriding `state_gas_reservoir` / `state_gas_reservoir_initial`
in `add_intrinsic_gas` after the normal derivation when `is_system_call`.
Uses the pre-computed `vm.state_gas_storage_set` field.

…UNT (bal-devnet-7)

EELS PR #2823 (commit eb80b438a) extends Policy A's top-level failure
refund so that a CREATE transaction that reverts or halts also returns
the intrinsic `STATE_BYTES_PER_NEW_ACCOUNT × cost_per_state_byte`
charge — paid via `add_intrinsic_gas` at tx start — back to the
reservoir. Mirrors the long-standing inner-CREATE failure rule.

Spec (fork.py::process_transaction):
  if tx_output.error is not None:
      tx_output.state_gas_left += tx_output.state_gas_used    # Policy A
      tx_output.state_gas_used = Uint(0)
      if isinstance(tx.to, Bytes0):
          new_account_refund = STATE_BYTES_PER_NEW_ACCOUNT * COST_PER_STATE_BYTE
          tx_output.state_gas_left += new_account_refund      # to reservoir
          tx_output.state_refund   += new_account_refund      # block-level

ethrex impl in `finalize_execution`, after the Policy A
execution-portion refund, when `is_create()`:
- `state_gas_reservoir += new_account_refund` (sender gets gas back)
- `state_gas_refund_absorbed += new_account_refund` (net block-level
  state_gas_used drops to 0 via the existing `net_state_gas_used`
  subtraction)
- `intrinsic_state_gas_charged -= new_account_refund` so
  `refund_sender`'s `regular_gas = raw_consumed - intrinsic_state - ...`
  formula doesn't double-deduct the now-refunded amount; the gas that
  was actually burned remains in the regular dimension where it sits.

Updates the existing `test_top_halt_phantom_drain_with_real_spill_under_policy_a`
test to assert the post-#2823 behavior: state_gas_used = 0 for a halted
CREATE tx (was state_new before).

…ate_gas_charged

Initial item-5 impl decremented `intrinsic_state_gas_charged` by
`new_account_refund` on top-level CREATE-tx failure, on the theory that
the refunded gas should not be subtracted from `raw_consumed` in the
regular-gas formula. That was wrong.

Per the EELS test_failed_create_tx_refunds_intrinsic_new_account
expectation:
  expected_gas_used = intrinsic_regular + regular_consumed
                    = gas_limit - create_state_gas
For an INVALID halt: expected = gas_limit - state_new.

`refund_sender`'s `regular_gas = raw_consumed - intrinsic_state - ...`
produces exactly that when `intrinsic_state_gas_charged` is left intact.
Clearing it overcounts regular by state_new (drops gas_used by state_new
in the wrong direction). Conceptually: the intrinsic burn is still in
`raw_consumed`, the refund returns it via the reservoir to the user,
and the regular-gas subtraction keeps it out of the regular dimension —
neither dimension counts it, which matches the spec.

Reservoir credit and `state_gas_refund_absorbed` bump (the two genuine
behavior changes from #2823) remain.

…-devnet-7)

Two fixes for the tx-level CREATE-collision path required by EELS
bal@v7.0.0:

1. Burn the forwarded gas in the regular dimension. EIP-684 + EELS
   `process_message_call` mark a CREATE-tx collision as
   `regular_gas_used = message.gas`. ethrex's collision branch in
   `handle_create_transaction` was returning with
   `current_call_frame.gas_remaining` still holding the
   post-intrinsic leftover, which leaked back to the sender as unused
   gas and never reached the regular dimension via
   `refund_sender`'s `raw_consumed - … + reclassified` formula. Now
   we zero `gas_remaining` so `raw_consumed = gas_limit` downstream.

2. Refund the intrinsic `STATE_BYTES_PER_NEW_ACCOUNT × CPSB` on
   collision. Previously the `!is_collision()` gate in
   `finalize_execution` excluded collision from BOTH Policy A and the
   item-5 NEW_ACCOUNT refund. Per EELS PR #2823 (commit eb80b438a)
   `process_transaction`, a tx-CREATE collision is just another
   failure variant that gets the intrinsic NEW_ACCOUNT refund:
       if tx_output.error is not None and isinstance(tx.to, Bytes0):
           tx_output.state_refund += create_state_gas
   Restructure the failure branch so Policy A still skips on
   collision (no execution state-gas to recover), but the
   `is_create()` intrinsic refund fires on every non-success.

After both: `regular_gas = gas_limit - intrinsic_state`,
`state_gas = 0`, header `gas_used = gas_limit - state_new` ✓
(matches EELS `test_create_tx_collision_refunds_intrinsic_new_account`).

Closes the 7-fixture CREATE-collision cluster in the bal-devnet-7
ef-test failures.

…t-7)

EELS PR #2823 (commit eb80b438a) simplifies `incorporate_child_on_error`
to:
    evm.state_gas_left += child_evm.state_gas_used + child_evm.state_gas_left

Removes the pre-#2823 subtraction of `child_evm.state_gas_refund` (the
"unwind on revert" of inline credits the child applied) on the rationale
that any inline credits the child applied are keyed to charges (its own
SSTORE or CREATE pre-charge) that are themselves rolled back, so the
matching `state_gas_left + state_gas_used` sum already reflects the
correct amount to return to the parent.

In ethrex's clamp-and-spill model the analogous tracking is the
`state_gas_refund_absorbed_snapshot` restore and the
`credit_against_drain_delta` subtraction in handle_return_call /
handle_return_create's Revert arms. Drop both.

Behavior change: an SSTORE 0→x→0 credit applied in a frame that later
reverts now leaks up to the parent's reservoir, matching the bal-7
test inversions:
- test_sstore_restoration_sub_frame_revert
- test_sstore_restoration_ancestor_revert
- test_subcall_set_clear_revert_pays_no_state_gas
and the broader stSStoreTest port group whose sub-contract calls
exercise this revert path.

Leaves `state_gas_used = state_gas_used_snapshot` (gross charges undone
on revert — same as before, matches EELS `state_gas_used` not flowing
to parent on error) and `state_gas_refund_pending = pending_snapshot`
(pending credits discarded with the child, per #2823 docstring).

…hannel (bal-devnet-7)

EIPs#11611 / EELS PR #2816 spec the EIP-7702 existing-authority refund
as a dedicated `MessageCallOutput.state_refund` channel: a separate
monotonic accumulator subtracted from `tx_state_gas` at the end of
`process_transaction`. `state_gas_used` and intrinsic state-gas are
explicitly kept immutable after validation so failure-path accounting
(Policy A's `execution_portion` math, regular-gas derivation, etc.)
stays consistent.

ethrex's prior implementation simulated the channel inline by
pre-decrementing both `state_gas_used` and `intrinsic_state_gas_charged`
in `set_delegation`. That worked on success (math nets out at refund_sender)
but corrupted every failure path because Policy A and the block-gas
formula re-derive from the pre-decremented counters — auth refunds
were double-applied, lost, or mis-routed depending on the failure mode.

This commit reifies the spec channel:
- New `VM.state_refund: u64` field (mirrors EELS `state_refund`)
- `set_delegation` (utils.rs:345-367): bumps `state_gas_reservoir` and
  `state_refund`; no longer touches `state_gas_used` or
  `intrinsic_state_gas_charged`
- `refund_sender` (default_hook.rs:254-264): subtracts `vm.state_refund`
  from the state dimension at the end, identically on success and failure

Fixes the 5 state_gas_set_code / intrinsic_gas_cost failures:
- auth_sender_billing_after_failure
- existing_account_auth_header_gas_used_reflects_refund
- existing_auth_refund_survives_top_level_revert
- auth_state_gas_in_header_after_failure
- prague/eip7702_set_code_tx/gas/intrinsic_gas_cost (duplicate-auth case)

`state_refund` lives on the VM, never snapshotted, so it naturally
survives revert/halt/OOG without any call-frame backup machinery.

EELS fork.py:1199-1205 computes per-tx state-gas as
  tx_state_gas = intrinsic_state_gas + state_gas_used - state_refund
and adds it to block_state_gas_used. Our `net_state_gas_used` was
subtracting only state_gas_refund_absorbed/pending and missing the
state_refund channel (EIP-7702 set_delegation refunds + CREATE-tx-failure
intrinsic NEW_ACCOUNT refunds). Result: block-level state dimension
inflated by the refund amount on those paths.

Fixes the 6 amsterdam/eip8037_state_creation_gas_cost_increase/state_gas_set_code
failures whose delta was exactly +183_600 (= NEW_ACCOUNT × CPSB).

Pre-bal-7 behavior charged the sender the full gas_limit on a tx-CREATE
address collision. EELS bal-devnet-7 (interpreter.py:120-145 + fork.py
failure block) preserves state_gas_reservoir across the collision and
adds new_account_refund to it, so:
  gas_spent = max(gas_limit - reservoir, calldata_floor)
  block_state_gas = 0
  block_regular_gas = effective_regular

The collision branch in default_hook also now subtracts both refund
channels (state_gas_refund_absorbed/pending + state_refund) from
state_gas so the block state dimension lands at 0 rather than
migrating into regular_gas via report.gas_used - report.state_gas_used.

Fixes 7 tests: 1 amsterdam (create_tx_collision_refunds_intrinsic_new_account)
and 6 paris/ported_static collision fixtures run under Amsterdam fork.

f4e47e1 over-corrected: dropping the state_gas_refund_absorbed
snapshot restore let reverted children's inline credits leak into the
parent's block-level deduction. EELS-equivalent per
incorporate_child_on_error is

  parent.state_gas_left += child.state_gas_used + child.state_gas_left

where EELS credit_state_gas_refund decrements the child's
state_gas_used (applied = min(amount, state_gas_used)). The child's
state_gas_used is therefore already net of any inline credits the
child applied.

Mapping to ethrex's gross-used + absorbed-deduction model:

  used_delta     = state_gas_used     - snapshot
  absorbed_delta = state_gas_refund_absorbed - snapshot
  child_net_used = used_delta - absorbed_delta
  new_reservoir  = state_gas_reservoir + child_net_used

state_gas_refund_absorbed is also restored to snapshot so the child's
absorbed credit dies with the child.

Fixes 22 SSTORE-restoration + ported_static/stSStoreTest failures.

The zkevm@v0.3.3 fixture bundle (the only bundle that ships
executionWitness, used by test-stateless-zkevm) is filled against an
older bal spec and disagrees with bal@v7.0.0 gas accounting:
storage_set/new_account/cpsb constants pre-recalibration plus pre-
EELS-#2815/#2816/#2823/#2827/#2828 refund-channel semantics.

Skips the 21 remaining gas mismatches in the eip8025_optional_proofs
filter (witness_codes_*, witness_state_*, validation_state_*),
analogous to the bal@v5.6.1 block already at the top of the list.
Re-enable once the zkevm bundle is regenerated against bal-7.

…n bal@v7.0.0)

Originally added in 530dd47 against snobal-devnet-6 fixtures and
bal-devnet-6 spec semantics. After the bal@v7.0.0 fixture bump
(94273e4) plus the EIP-8037/EIP-7702 alignment commits, these
Amsterdam-fork tests pass and the skips are obsolete.

**Motivation**

When an account creation reverts, we incorrectly mark it as existing for
the purposes of EIP7702, leading to charging gas incorrectly.

**Description**

Currently we track accounts that exist in the trie for purposes of
charging EIP7702 gas (the price is different if the authority already
exists in the trie). This is saved in the `exists` field of the account,
which is currently not saved in the callframe backup.

This means when an account creation is reverted, we don't unmark it as
existing. This causes an incorrect amount of gas to be charged.

The PR contains a regression test, that should fail on the first commit
and pass on the second.

…ation

Mirrors EELS PR #2836 (merged 2026-05-12, devnets/bal/7):
ethereum/execution-specs#2836

When the authority's pre-state code slot already holds a 7702 delegation
indicator (overwrite or clear), refill the 23-byte AUTH_BASE portion of
intrinsic state gas via both the reservoir and the state_refund channel.
Keys off the pre-state code, not the auth target, so it applies whether
auth.address is a new delegation target or zero (clear).

Breaks ef-tests until upstream re-cuts fixtures past tests-bal@v7.0.0;
no skips added per the bal-devnet-7 alignment policy.

Mirrors EELS PR #2845 (tests-bal@v7.1.0, devnets/bal/7): all SELFDESTRUCT
state-gas refunds are removed from EIP-8037. Drops the
apply_same_tx_selfdestruct_state_refund pass and its call site in the
default hook; shared clamp-and-spill bookkeeping fields stay.

Updates the Amsterdam fixture URL (now hosted on execution-specs releases)
and the hive eels_commit to 73083f054c (tip of tests-bal@v7.1.0). Local
ef-tests blockchain suite: 8721/0/0 passing.

…t diff

When BAL validation fails on a balance change, the error now prints the
wei diff plus a heuristic that maps it to a multiple of well-known
EIP-8037 state-gas constants (NEW_ACCOUNT, STORAGE_SET, AUTH_BASE,
AUTH_TOTAL) at common test gas_prices. Avoids manual division and
recognition of stride constants when triaging spec/fixture drift.

Also adds a regression test that decodes the exact sender BalanceChange
bytes from the tests-bal@v7.1.0 fixture for
`test_call_value_to_self_destructed_same_tx_account`, so a future
encoding/serde change can't silently shift the parsed `post_balance`.

These entries described the snobal-devnet-6 fixture-vs-impl mismatch:
74 blockchain ef-tests under SKIPPED_BASE and the matching 32 hive
consume-engine test functions under KNOWN_EXCLUDED_TESTS. Both sets
share the same root cause and the same fix: bumping fixtures to bal@v7
and aligning the impl with bal-devnet-7 semantics.

The blockchain skip list was removed in 8e6f3c6 ("unskip 74
bal-devnet-6 Amsterdam fixtures"); the corresponding docs and hive
exclusions were left behind. After the v7.1.0 fixture bump and a clean
2,145/2,145 hive `bal` run, neither set of tests fails anymore.

Keep the stateless / EIP-8025 zkevm@v0.3.3 entry in known_issues.md
(still valid; zkevm bundle is pre-bal-7).
Keep the three flaky hive-framework `Invalid Missing Ancestor` patterns
in check-hive-results.sh (unrelated to bal-devnet anything).

ethrex ab15f37 hardened the HTTP JSON-RPC defaults, gating
`admin_*`/`debug_*`/`txpool_*` behind a new `--http.api` allowlist.
Hive c4d839b3 (#1485) feature-detects the flag in `clients/ethrex/
ethrex.sh` and opts those namespaces back in. The pinned version
`1c27560a` predates that fix, so hive runs against current main start
ethrex without the namespace allowlist and any test touching the
gated namespaces gets `MethodNotFound`.

Bump to current hive HEAD (3b6bde03), which includes the fix plus a
Cargo.lock dependency-drift safeguard (#1492).

Mirrors EELS PR #2848 (tests-bal@v7.1.1, devnets/bal/7):
ethereum/execution-specs#2848

PR #2836 already refunded the 23-byte AUTH_BASE portion when the
authority's pre-state code slot held a delegation indicator. #2848
broadens the condition: when the auth is a clear (`auth.address ==
0x00`), no new indicator bytes are written regardless of pre-state
code, so the AUTH_BASE refill applies even against an authority with
no prior code.

Equivalent to EELS:
    if authority_account.code_hash != EMPTY_CODE_HASH
       or auth.address == NULL_ADDRESS:
        refund = STATE_BYTES_PER_AUTH_BASE * COST_PER_STATE_BYTE

Picks up EELS PR #2848 (refund AUTH_BASE on delegation clear),
implemented in the previous commit. Eels_commit bumped to bcb8dc5f8
(tip of tests-bal@v7.1.1).