feat(tests): EIP-8037 state-gas refund on failed CREATE2 with init storage (#3011)

Co-authored-by: spencer-tb <spencer.tb@ethereum.org>

Author: bshastry

docs/writing_tests/post_mortems.md

@@ -72,6 +72,52 @@ None required - the existing framework supported writing these tests.
 
 ---
 
+## 2026-06 - CREATE2 Failed Deposit Storage State-Gas Refund - Amsterdam
+
+### Description
+
+A consensus divergence was found via goevmlab differential fuzzing in
+go-ethereum's Amsterdam (bal-devnet-7) EIP-8037 implementation: when a `CREATE2`
+whose init code writes new storage slots fails its code deposit — either because
+the deposited code is rejected by EIP-3541, or because the EIP-8037 code-deposit
+state gas cannot be paid — the create frame reverts, but only the new-account
+state-creation gas is refunded; the init's storage-slot state-creation gas
+(`STATE_BYTES_PER_STORAGE_SET * COST_PER_STATE_BYTE` per slot) is not. The
+transaction over-reports gas used (by `num_slots * 97920`), so the sender and
+coinbase balances — and the post-state root — diverge from the reference spec
+and from revm/nethermind/besu/erigon/ethrex.
+
+### Root Cause Analysis
+
+- State-creation gas charged inside a `CREATE`/`CREATE2` init frame must be fully
+  reverted when the create fails, for both the new account and any storage slots
+  the init wrote. The existing `eip8037` suite covered the create-init storage
+  charge on the success path and same-tx slot-reset refunds, but never isolated
+  the refund of storage-slot state gas on a create *failure*.
+- The new-account state-gas refund on failure was already correct, which masked
+  the missing storage-slot refund: a failing create with no init storage agrees
+  across clients, so only the combination "failing create + init storage"
+  exposes it.
+- Differential fuzzing (goevmlab) surfaced it where direct enumeration had not.
+
+### Steps Taken To Avoid Recurrence
+
+- Added a parametric regression test over the failure mechanism (EIP-3541 reject
+  and code-deposit OOG) and the number of init storage slots (`0`, `1`, `3`). The
+  `slots=0` case is a negative control (account-creation refund only) that must
+  not diverge; the `slots>=1` cases isolate the storage-slot state-gas refund on
+  create failure and scale the discrepancy with the slot count.
+
+### Implemented Test Case
+
+- `tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py::test_create2_failed_deposit_refunds_storage_state_gas`
+
+### Framework/Documentation Changes
+
+None required - the existing framework supported writing this test.
+
+---
+
 ## TEMPLATE
 
 ## Date - Title - Fork

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -1869,6 +1869,62 @@ def test_create_code_deposit_oog_refunds_state_gas(
     state_test(pre=pre, post={factory: Account(storage=storage)}, tx=tx)
 
 
+@pytest.mark.parametrize("slots", [0, 1, 3])
+@pytest.mark.parametrize("fail_mode", ["eip3541", "oog_deposit"])
+@pytest.mark.valid_from("EIP8037")
+def test_create2_failed_deposit_refunds_storage_state_gas(
+    state_test: StateTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    slots: int,
+    fail_mode: str,
+) -> None:
+    """
+    Test a failed CREATE2 deposit refunds the init's storage-slot state gas.
+
+    Total gas used is independent of `slots`, so a client that drops the
+    slot refund diverges for `slots >= 1`; `slots == 0` is the negative
+    control.
+    """
+    gas_limit_cap = fork.transaction_gas_limit_cap()
+    assert gas_limit_cap is not None
+
+    # init: write `slots` new storage slots, then trigger a deposit failure
+    init_code = Bytecode()
+    for i in range(slots):
+        init_code += Op.SSTORE(i, i + 1)
+    if fail_mode == "eip3541":
+        # return 0xEF -> EIP-3541 rejects the deposited code
+        init_code += Op.MSTORE8(0, 0xEF) + Op.RETURN(0, 1)
+    else:
+        # return max-size code: the code-deposit state gas cannot be paid
+        init_code += Op.RETURN(0, fork.max_code_size())
+    mstore_value, size = init_code_at_high_bytes(init_code)
+
+    storage = Storage()
+    factory = pre.deploy_contract(
+        code=(
+            Op.MSTORE(0, mstore_value)
+            + Op.SSTORE(
+                storage.store_next(0, "create2_failed"),
+                Op.CREATE2(value=0, offset=0, size=size, salt=0),
+            )
+        ),
+    )
+
+    tx = Transaction(
+        to=factory,
+        gas_limit=gas_limit_cap,
+        sender=pre.fund_eoa(),
+    )
+
+    state_test(
+        pre=pre,
+        post={factory: Account(storage=storage)},
+        tx=tx,
+    )
+
+
 @pytest.mark.parametrize(
     "reservoir_covers",
     [