fix(test): proper gas accounting across tests; should help with any gas changes

Author: fselmo

tests/amsterdam/eip7843_slotnum/test_slotnum.py

@@ -6,6 +6,7 @@
     Alloc,
     Environment,
     Fork,
+    Header,
     Op,
     StateTestFiller,
     Transaction,
@@ -32,6 +33,7 @@
 def test_slotnum_value(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     slot_number: int,
 ) -> None:
     """
@@ -40,27 +42,37 @@ def test_slotnum_value(
     The slot number is provided by the consensus layer and should be
     accessible via the SLOTNUM opcode (0x4B).
     """
-    # Store SLOTNUM result at storage key 0
-    code = Op.SSTORE(0, Op.SLOTNUM)
+    # Store SLOTNUM result at storage key 0. Metadata pins the
+    # storage transition (0->slot_number) so `code.gas_cost(fork)`
+    # picks the right SSTORE branch under EIP-8037's 2D gas model.
+    code = Op.SSTORE(
+        key=0,
+        value=Op.SLOTNUM,
+        key_warm=False,
+        original_value=0,
+        new_value=slot_number,
+    )
     code_address = pre.deploy_contract(code)
 
+    intrinsic_cost = fork.transaction_intrinsic_cost_calculator()()
+    code_state = code.state_cost(fork)
+    code_regular = code.gas_cost(fork) - code_state
+
     tx = Transaction(
         sender=pre.fund_eoa(),
-        gas_limit=100_000,
+        gas_limit=intrinsic_cost + code_regular + code_state,
         to=code_address,
     )
 
-    post = {
-        code_address: Account(
-            storage={0: slot_number},
-        ),
-    }
+    # block.gas_used = max(regular_dimension, state_dimension).
+    expected_gas_used = max(intrinsic_cost + code_regular, code_state)
 
     state_test(
         env=Environment(slot_number=slot_number),
         pre=pre,
         tx=tx,
-        post=post,
+        post={code_address: Account(storage={0: slot_number})},
+        blockchain_test_header_verify=Header(gas_used=expected_gas_used),
     )
 
 
@@ -88,25 +100,42 @@ def test_slotnum_gas_cost(
     callee_code = Op.SLOTNUM + Op.STOP
     callee_address = pre.deterministic_deploy_contract(deploy_code=callee_code)
 
-    # Caller calls the callee with limited gas and stores result
-    caller_code = Op.SSTORE(0, Op.CALL(gas=call_gas, address=callee_address))
+    # Caller calls the callee with `call_gas`; SSTOREs the call's
+    # success bit (1 if SLOTNUM had enough gas, 0 if it OOG'd).
+    sstore_value = 1 if call_succeeds else 0
+    caller_code = Op.SSTORE(
+        key=0,
+        value=Op.CALL(
+            gas=call_gas,
+            address=callee_address,
+            address_warm=False,
+        ),
+        key_warm=False,
+        original_value=0,
+        new_value=sstore_value,
+    )
     caller_address = pre.deploy_contract(caller_code)
 
+    intrinsic_cost = fork.transaction_intrinsic_cost_calculator()()
+    code_state = caller_code.state_cost(fork)
+    # Static opcode-metadata calc misses the gas burned in the inner
+    # CALL frame; add it back. `call_gas` is the full forwarded amount
+    # — for `enough_gas` SLOTNUM consumes it all; for `out_of_gas`
+    # the OOG burns the entire forwarded budget.
+    code_regular = caller_code.gas_cost(fork) - code_state + call_gas
+
     tx = Transaction(
         sender=pre.fund_eoa(),
-        gas_limit=100_000,
+        gas_limit=intrinsic_cost + code_regular + code_state,
         to=caller_address,
     )
 
-    post = {
-        caller_address: Account(
-            storage={0: 1 if call_succeeds else 0},
-        ),
-    }
+    expected_gas_used = max(intrinsic_cost + code_regular, code_state)
 
     state_test(
         env=Environment(slot_number=12345),
         pre=pre,
         tx=tx,
-        post=post,
+        post={caller_address: Account(storage={0: sstore_value})},
+        blockchain_test_header_verify=Header(gas_used=expected_gas_used),
     )

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists.py

@@ -367,35 +367,51 @@ def test_bal_callcode_nested_value_transfer(
     "delegated_opcode",
     [
         pytest.param(
-            lambda target_addr: Op.DELEGATECALL(
-                50000, target_addr, 0, 0, 0, 0
+            lambda target_addr, inner_gas: Op.DELEGATECALL(
+                inner_gas, target_addr, 0, 0, 0, 0
             ),
             id="delegatecall",
         ),
         pytest.param(
-            lambda target_addr: Op.CALLCODE(50000, target_addr, 0, 0, 0, 0, 0),
+            lambda target_addr, inner_gas: Op.CALLCODE(
+                inner_gas, target_addr, 0, 0, 0, 0, 0
+            ),
             id="callcode",
         ),
     ],
 )
 def test_bal_delegated_storage_writes(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,
-    delegated_opcode: Callable[[Address], Op],
+    delegated_opcode: Callable[[Address, int], Op],
+    fork: Fork,
 ) -> None:
     """
     Ensure BAL captures delegated storage writes via
     DELEGATECALL and CALLCODE.
     """
     alice = pre.fund_eoa()
 
-    # TargetContract that writes 0x42 to slot 0x01
-    target_code = Op.SSTORE(0x01, 0x42)
+    # TargetContract that writes 0x42 to slot 0x01.
+    # Metadata pins the 0->0x42 transition so the gas calculator
+    # accounts for SSTORE state gas under EIP-8037.
+    target_code = Op.SSTORE.with_metadata(
+        key_warm=False,
+        original_value=0,
+        current_value=0,
+        new_value=0x42,
+    )(0x01, 0x42)
     target_contract = pre.deploy_contract(code=target_code)
 
+    # Forward enough inner gas to cover both the regular and (under
+    # EIP-8037) the spilled state-gas portion of the SSTORE — the
+    # oracle frame inherits `state_gas_reservoir=0` since the outer
+    # tx_gas stays below TX_MAX_GAS_LIMIT.
+    inner_gas = target_code.gas_cost(fork) + 100  # small buffer
+
     # Oracle contract that uses delegated opcode to execute
     # TargetContract's code
-    oracle_code = delegated_opcode(target_contract)
+    oracle_code = delegated_opcode(target_contract, inner_gas)
     oracle_contract = pre.deploy_contract(code=oracle_code)
 
     tx = Transaction(
@@ -2133,6 +2149,7 @@ def test_bal_create_transaction_empty_code(
 def test_bal_cross_tx_storage_revert_to_zero(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,
+    fork: Fork,
 ) -> None:
     """
     Ensure BAL captures storage changes when tx1 writes a non-zero value
@@ -2148,20 +2165,42 @@ def test_bal_cross_tx_storage_revert_to_zero(
     # Contract that writes to slot 0 based on calldata
     contract = pre.deploy_contract(code=Op.SSTORE(0, Op.CALLDATALOAD(0)))
 
+    # Size each tx_gas_limit precisely against its SSTORE transition
+    # under EIP-8037's 2D gas model (regular + state).
+    intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
+    tx1_data = Hash(0xABCD)
+    tx2_data = Hash(0x0)
+    tx1_code = Op.SSTORE.with_metadata(
+        key_warm=False,
+        original_value=0,
+        current_value=0,
+        new_value=0xABCD,
+    )(0, Op.CALLDATALOAD(0))
+    tx2_code = Op.SSTORE.with_metadata(
+        key_warm=False,
+        original_value=0xABCD,
+        current_value=0xABCD,
+        new_value=0x0,
+    )(0, Op.CALLDATALOAD(0))
+
     # Tx1: Write slot 0 = 0xABCD
     tx1 = Transaction(
         sender=alice,
         to=contract,
-        data=Hash(0xABCD),
-        gas_limit=100_000,
+        data=tx1_data,
+        gas_limit=(
+            intrinsic_calc(calldata=tx1_data) + tx1_code.gas_cost(fork)
+        ),
     )
 
     # Tx2: Write slot 0 = 0x0 (revert to zero)
     tx2 = Transaction(
         sender=alice,
         to=contract,
-        data=Hash(0x0),
-        gas_limit=100_000,
+        data=tx2_data,
+        gas_limit=(
+            intrinsic_calc(calldata=tx2_data) + tx2_code.gas_cost(fork)
+        ),
     )
 
     account_expectations = {

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_cross_index.py

@@ -21,6 +21,7 @@
     BlockAccessListExpectation,
     BlockchainTestFiller,
     Bytecode,
+    Fork,
     Op,
     Transaction,
 )
@@ -192,6 +193,7 @@ def test_bal_consolidation_contract_cross_index(
 def test_bal_noop_write_filtering(
     pre: Alloc,
     blockchain_test: BlockchainTestFiller,
+    fork: Fork,
 ) -> None:
     """
     Test that NOOP writes (writing same value or 0 to empty) are filtered.
@@ -201,15 +203,37 @@ def test_bal_noop_write_filtering(
     2. Writing the same value to a slot doesn't appear in BAL
     3. Only actual changes are tracked
     """
+    # Metadata pins each SSTORE's actual transition so the gas
+    # calculator picks the right branch under EIP-8037's 2D model.
     test_code = Bytecode(
         # Write 0 to uninitialized slot 1 (noop)
-        Op.SSTORE(1, 0)
-        # Write 42 to slot 2
-        + Op.SSTORE(2, 42)
-        # Write 100 to slot 3 (will be same as pre-state, should be filtered)
-        + Op.SSTORE(3, 100)
-        # Write 200 to slot 4 (different from pre-state 150, should appear)
-        + Op.SSTORE(4, 200)
+        Op.SSTORE.with_metadata(
+            key_warm=False,
+            original_value=0,
+            current_value=0,
+            new_value=0,
+        )(1, 0)
+        # Write 42 to slot 2 (0->42, charges sstore_state_gas)
+        + Op.SSTORE.with_metadata(
+            key_warm=False,
+            original_value=0,
+            current_value=0,
+            new_value=42,
+        )(2, 42)
+        # Write 100 to slot 3 (same as pre-state, should be filtered)
+        + Op.SSTORE.with_metadata(
+            key_warm=False,
+            original_value=100,
+            current_value=100,
+            new_value=100,
+        )(3, 100)
+        # Write 200 to slot 4 (150->200, regular update)
+        + Op.SSTORE.with_metadata(
+            key_warm=False,
+            original_value=150,
+            current_value=150,
+            new_value=200,
+        )(4, 200)
     )
 
     sender = pre.fund_eoa()
@@ -218,10 +242,11 @@ def test_bal_noop_write_filtering(
         storage={3: 100, 4: 150},
     )
 
+    intrinsic_cost = fork.transaction_intrinsic_cost_calculator()()
     tx = Transaction(
         sender=sender,
         to=test_address,
-        gas_limit=100_000,
+        gas_limit=intrinsic_cost + test_code.gas_cost(fork),
     )
 
     # Expected BAL should only show actual changes

tests/amsterdam/eip8024_dupn_swapn_exchange/test_swapn.py

@@ -10,6 +10,8 @@
     Account,
     Alloc,
     Bytecode,
+    Fork,
+    Header,
     Op,
     StateTestFiller,
     Transaction,
@@ -142,6 +144,7 @@ def test_swapn_valid_immediates(
 def test_swapn_preserves_other_stack_items(
     pre: Alloc,
     state_test: StateTestFiller,
+    fork: Fork,
 ) -> None:
     """Test SWAPN only swaps the specified items, leaving others unchanged."""
     sender = pre.fund_eoa()
@@ -151,6 +154,16 @@ def test_swapn_preserves_other_stack_items(
     stack_index = 17
     stack_height = stack_index + 1  # Need 18 items
 
+    # Compute expected storage values (post-swap stack reads).
+    expected_storage: dict = {}
+    for i in range(stack_height):
+        if i == 0:
+            expected_storage[i] = 0x1000  # Was at bottom, now at top
+        elif i == stack_height - 1:
+            expected_storage[i] = 0x1011  # Was at top, now at bottom
+        else:
+            expected_storage[i] = 0x1000 + (stack_height - 1 - i)
+
     # Create a stack with 18 distinct values
     code = Bytecode()
     for i in range(stack_height):
@@ -160,31 +173,39 @@ def test_swapn_preserves_other_stack_items(
     # Pass stack index directly - encoder will handle encoding
     code += Op.SWAPN[stack_index]
 
-    # Store all values to verify only the swapped ones changed
+    # Store all values; metadata pins each slot's 0->non-zero
+    # transition so `code.gas_cost(fork)` accounts for SSTORE state
+    # gas under EIP-8037.
     for i in range(stack_height):
-        code += Op.PUSH1(i) + Op.SSTORE
+        code += Op.PUSH1(i) + Op.SSTORE.with_metadata(
+            key_warm=False,
+            original_value=0,
+            current_value=0,
+            new_value=expected_storage[i],
+        )
 
     code += Op.STOP
 
     contract_address = pre.deploy_contract(code=code)
 
-    tx = Transaction(to=contract_address, sender=sender, gas_limit=1_000_000)
+    intrinsic_cost = fork.transaction_intrinsic_cost_calculator()()
+    code_state = code.state_cost(fork)
+    code_regular = code.gas_cost(fork) - code_state
 
-    # After swap: position 1 and position 18 are swapped
-    # Original stack (top to bottom): 0x1011, 0x1010, ..., 0x1001, 0x1000
-    # After SWAPN[0]: 0x1000, 0x1010, ..., 0x1001, 0x1011
-    expected_storage = {}
-    for i in range(stack_height):
-        if i == 0:
-            expected_storage[i] = 0x1000  # Was at bottom, now at top
-        elif i == stack_height - 1:
-            expected_storage[i] = 0x1011  # Was at top, now at bottom
-        else:
-            expected_storage[i] = 0x1000 + (stack_height - 1 - i)
+    tx = Transaction(
+        to=contract_address,
+        sender=sender,
+        gas_limit=intrinsic_cost + code_regular + code_state,
+    )
 
-    post = {contract_address: Account(storage=expected_storage)}
+    expected_gas_used = max(intrinsic_cost + code_regular, code_state)
 
-    state_test(pre=pre, post=post, tx=tx)
+    state_test(
+        pre=pre,
+        post={contract_address: Account(storage=expected_storage)},
+        tx=tx,
+        blockchain_test_header_verify=Header(gas_used=expected_gas_used),
+    )
 
 
 def test_swapn_stack_underflow(