fix(tests): drop brittle header_verify on CALL-to-selfdestructed tests

The three regression-fix tests in commit 4828ae6 used hardcoded
empirical `block_regular` dicts (per CREATE/CREATE2 x
self/external variant) to discriminate a spurious
`GAS_NEW_ACCOUNT` charge on the CALL. The dicts are brittle to any
regular-gas constant change and the spurious-charge discriminator
is redundant: PR ethereum#2707's own tests (`test_create_selfdestruct_*`)
already exercise the refund path.

Drop `header_verify` from:
  test_call_value_to_self_destructed_header_gas_used
  test_call_value_to_self_destructed_burns_value
  test_call_zero_value_to_self_destructed_same_tx_account

The tests still verify runtime behavior: NONEXISTENT created
address and orchestrator balance burned to zero.

Also adds a cross-over test for the ethereum#2704 + ethereum#2689 refund
composition that PR ethereum#2704 does not exercise directly:

  test_inner_create_fail_refunds_in_creation_tx (parametrized
    `outer_outcome` in {succeeds, reverts}, `num_inner_ops` in
    {1, 3}, `create_opcode` in {CREATE, CREATE2})
    Creation tx with `num_inner_ops` inner CREATE/CREATE2 calls
    whose initcode REVERTs. Each inner CREATE's GAS_NEW_ACCOUNT
    is refunded by PR ethereum#2704. Outer then succeeds or reverts.
    block_state == outer intrinsic in both cases; a client that
    regressed to pre-ethereum#2704 "gas persists" behavior would inflate
    it by `num_inner_ops * GAS_NEW_ACCOUNT`. Rewrites the
    inverted-premise test from the closed PR ethereum#2639.

Author: spencer-tb

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_call.py

@@ -1055,34 +1055,13 @@ def test_call_value_to_self_destructed_header_gas_used(
     )
 
     # Post-EIP-11532 (PR #2707): the same-tx CREATE + SELFDESTRUCT
-    # refund zeroes `block_state_gas_used` at end-of-tx, so the
-    # header `gas_used` equals `block_regular`. A spurious
-    # `GAS_NEW_ACCOUNT` charge on the CALL would inflate
-    # `state_gas_used` by 131,488 and bump the header to that
-    # value, so `expected < new_account_state_gas` is the sharp
-    # discriminator. Values below are empirical block_regular
-    # (they depend only on fork-stable regular gas constants, not
-    # on cost_per_state_byte).
-    expected_by_variant = {
-        (Op.CREATE, "self"): 41864,
-        (Op.CREATE, "external"): 44465,
-        (Op.CREATE2, "self"): 41873,
-        (Op.CREATE2, "external"): 44474,
-    }
-    expected = expected_by_variant[(create_opcode, selfdestruct_beneficiary)]
-    assert expected < new_account_state_gas, (
-        "expected must stay below new_account_state_gas for the "
-        "spurious-charge discriminator to be sharp"
-    )
-
+    # refund zeroes `block_state_gas_used`. The previous header
+    # gas_used assertion (`== new_account_state_gas`) no longer
+    # holds. PR #2707's own tests discriminate the refund path,
+    # so this test's role reduces to the happy-path smoke check.
     blockchain_test(
         pre=pre,
-        blocks=[
-            Block(
-                txs=[tx],
-                header_verify=Header(gas_used=expected),
-            ),
-        ],
+        blocks=[Block(txs=[tx])],
         post={},
     )
 
@@ -1168,33 +1147,13 @@ def test_call_value_to_self_destructed_burns_value(
     )
 
     # Post-EIP-11532 (PR #2707): the same-tx CREATE + SELFDESTRUCT
-    # refund zeroes `block_state_gas_used` at end-of-tx, so the
-    # header reports `block_regular`. A spurious charge on the
-    # value-bearing CALL would bump `state_gas_used` by 131,488
-    # and push the header above `new_account_state_gas`, so
-    # `expected < new_account_state_gas` is the sharp
-    # discriminator. `call_value` does not change regular gas
-    # (value transfer adds a constant 9,000 to the CALL opcode
-    # regardless of amount). Values below are empirical
-    # block_regular.
-    expected_by_opcode = {
-        Op.CREATE: 41864,
-        Op.CREATE2: 41873,
-    }
-    expected = expected_by_opcode[create_opcode]
-    assert expected < new_account_state_gas, (
-        "expected must stay below new_account_state_gas for the "
-        "spurious-charge discriminator to be sharp"
-    )
-
+    # refund zeroes `block_state_gas_used`. The value-burning
+    # property is captured by the post state: `created_address`
+    # NONEXISTENT (destroyed end-of-tx) and the orchestrator's
+    # balance drained to zero.
     blockchain_test(
         pre=pre,
-        blocks=[
-            Block(
-                txs=[tx],
-                header_verify=Header(gas_used=expected),
-            ),
-        ],
+        blocks=[Block(txs=[tx])],
         post={
             created_address: Account.NONEXISTENT,
             orchestrator: Account(balance=0),
@@ -1255,30 +1214,12 @@ def test_call_zero_value_to_self_destructed_same_tx_account(
     )
 
     # Post-EIP-11532 (PR #2707): the same-tx CREATE + SELFDESTRUCT
-    # refund zeroes `block_state_gas_used`, so header `gas_used`
-    # equals `block_regular`. A spurious new-account charge on the
-    # zero-value CALL (value-gate broken) would push the header
-    # above `new_account_state_gas`, so
-    # `expected < new_account_state_gas` is the sharp
-    # discriminator. Values below are empirical block_regular.
-    expected_by_opcode = {
-        Op.CREATE: 35164,
-        Op.CREATE2: 35173,
-    }
-    expected = expected_by_opcode[create_opcode]
-    assert expected < new_account_state_gas, (
-        "expected must stay below new_account_state_gas for the "
-        "spurious-charge discriminator to be sharp"
-    )
-
+    # refund zeroes `block_state_gas_used`. The happy-path
+    # storage and runtime behavior is sufficient; the refund
+    # itself is discriminated by PR #2707's dedicated tests.
     blockchain_test(
         pre=pre,
-        blocks=[
-            Block(
-                txs=[tx],
-                header_verify=Header(gas_used=expected),
-            ),
-        ],
+        blocks=[Block(txs=[tx])],
         post={},
     )
 

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -2084,3 +2084,130 @@ def test_create_stack_depth_state_gas_consumed(
 
     post = {recursive: Account(storage=storage)}
     state_test(pre=pre, post=post, tx=tx)
+
+
+@pytest.mark.parametrize(
+    "num_inner_ops",
+    [
+        pytest.param(1, id="single"),
+        pytest.param(3, id="accumulate"),
+    ],
+)
+@pytest.mark.parametrize(
+    "outer_outcome",
+    [
+        pytest.param("succeeds", id="outer_succeeds"),
+        pytest.param("reverts", id="outer_reverts"),
+    ],
+)
+@pytest.mark.with_all_create_opcodes()
+@pytest.mark.valid_from("EIP8037")
+def test_inner_create_fail_refunds_in_creation_tx(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    create_opcode: Op,
+    outer_outcome: str,
+    num_inner_ops: int,
+) -> None:
+    """
+    Cross-over: PR #2704 CREATE failure refund in a creation-tx context.
+
+    The original closed PR #2639 test asserted inner CREATE's
+    `GAS_NEW_ACCOUNT` PERSISTS on child failure (targeting a
+    bal-devnet-3 geth behavior). PR #2704 subsequently changed the
+    spec to refund that charge, inverting the original premise.
+    This test covers the CURRENT spec behavior in a scenario not
+    exercised by PR #2704's own tests (which all use non-creation
+    factories):
+
+    A creation tx (to=None) whose initcode performs `num_inner_ops`
+    inner CREATE/CREATE2 calls with REVERT initcode. Each inner
+    CREATE charges `GAS_NEW_ACCOUNT` state then refunds it via the
+    child-error branch (PR #2704). The outer initcode then
+    terminates via RETURN (succeeds) or REVERT.
+
+    Both outcomes yield `block_state = outer intrinsic` because
+    inner refunds net the state gas back to zero; PR #2689's top
+    level refund (applied on revert) is a no-op over an already
+    zeroed `state_gas_used`.
+
+    A client that regresses to the pre-#2704 "persist" behavior
+    would inflate `block_state` by `num_inner_ops * GAS_NEW_ACCOUNT`.
+    The `outer_halts` variant is omitted because `INVALID` absorbs
+    all remaining gas into `regular_gas_used`, letting `block_regular`
+    dominate the header and dilute the state dimension signal.
+    """
+    gas_costs = fork.gas_costs()
+    outer_state_gas = fork.create_state_gas(code_size=0)
+
+    inner_initcode = bytes(Op.REVERT(0, 0))
+
+    setup = Op.MSTORE(
+        0,
+        int.from_bytes(inner_initcode, "big")
+        << (256 - 8 * len(inner_initcode)),
+    )
+
+    inner_ops = Bytecode()
+    for i in range(num_inner_ops):
+        if create_opcode == Op.CREATE2:
+            inner_ops += Op.POP(Op.CREATE2(0, 0, len(inner_initcode), i))
+        else:
+            inner_ops += Op.POP(Op.CREATE(0, 0, len(inner_initcode)))
+
+    if outer_outcome == "succeeds":
+        termination = Op.RETURN(0, 0)
+    elif outer_outcome == "reverts":
+        termination = Op.REVERT(0, 0)
+    else:
+        termination = Op.INVALID
+
+    initcode = setup + inner_ops + termination
+
+    sender = pre.fund_eoa()
+    intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
+    intrinsic_total = intrinsic_calc(
+        calldata=bytes(initcode), contract_creation=True
+    )
+
+    # Gas budget: enough for each inner CREATE to charge
+    # GAS_NEW_ACCOUNT (spill into gas_left, then get refunded on
+    # child failure) and for the outer termination to run.
+    initcode_gas = initcode.gas_cost(fork)
+    per_inner_slack = 2_000
+    gas_limit = (
+        intrinsic_total
+        + initcode_gas
+        + num_inner_ops * (gas_costs.GAS_NEW_ACCOUNT + per_inner_slack)
+    )
+
+    # Expected: only outer intrinsic remains in block_state. Each
+    # inner CREATE's charge is refunded by PR #2704; any residue
+    # left in state_gas_used is zeroed on outer failure by PR #2689.
+    expected_state = outer_state_gas
+
+    create_address = compute_create_address(address=sender, nonce=0)
+
+    tx = Transaction(
+        sender=sender,
+        to=None,
+        data=initcode,
+        gas_limit=gas_limit,
+    )
+
+    if outer_outcome == "succeeds":
+        post: dict = {create_address: Account(code=b"")}
+    else:
+        post = {create_address: Account.NONEXISTENT}
+
+    blockchain_test(
+        pre=pre,
+        blocks=[
+            Block(
+                txs=[tx],
+                header_verify=Header(gas_used=expected_state),
+            ),
+        ],
+        post=post,
+    )