chore(test): cleanup / review for 8037 byte value updates

Author: fselmo

packages/testing/src/execution_testing/cli/pytest_commands/plugins/shared/transaction_fixtures.py

@@ -91,9 +91,7 @@ def type_3_default_transaction(sender: EOA) -> Transaction:
 
 
 @pytest.fixture
-def type_4_default_transaction(
-    sender: EOA, pre: Alloc, fork: Fork
-) -> Transaction:
+def type_4_default_transaction(sender: EOA, pre: Alloc) -> Transaction:
     """Type 4 (set code) default transaction introduced in Prague fork."""
     # Create authorized accounts with funds
     auth_signer1 = pre.fund_eoa(amount=10**18)
@@ -103,14 +101,12 @@ def type_4_default_transaction(
     target1 = pre.deploy_contract(Op.SSTORE(0, 1))
     target2 = pre.deploy_contract(Op.SSTORE(0, 1))
 
-    # Recipient may be a nonexistent account (e.g., EIP-7708 transfer
-    # log tests), so cover one NEW_ACCOUNT state charge.
     return Transaction(
         ty=4,
         sender=sender,
         max_fee_per_gas=10**10,
         max_priority_fee_per_gas=10**9,
-        gas_limit=500_000 + fork.gas_costs().NEW_ACCOUNT,
+        gas_limit=500_000,
         data=b"\x00" * 200,
         access_list=[
             AccessList(address=0x4567, storage_keys=[1000, 2000, 3000]),

packages/testing/src/execution_testing/forks/forks/eips/amsterdam/eip_8037.py

@@ -19,6 +19,15 @@
 from ....base_fork import BaseFork
 from ....gas_costs import GasCosts
 
+# EIP-8037 state byte sizes (mirrors EELS amsterdam/vm/gas.py).
+STATE_BYTES_PER_NEW_ACCOUNT = 120
+STATE_BYTES_PER_STORAGE_SET = 64
+STATE_BYTES_PER_AUTH_BASE = 23
+
+# EIP-8037 regular gas base costs.
+PER_AUTH_BASE_COST = 7_500
+REGULAR_GAS_CREATE = 9_000
+
 
 class EIP8037(BaseFork):
     """EIP-8037 class."""
@@ -33,7 +42,6 @@ def cost_per_state_byte(cls) -> int:
     @classmethod
     def sstore_state_gas(cls) -> int:
         """Return state gas for a zero-to-nonzero SSTORE (EIP-8037)."""
-        STATE_BYTES_PER_STORAGE_SET = 64  # noqa: N806
         return STATE_BYTES_PER_STORAGE_SET * cls.cost_per_state_byte()
 
     @classmethod
@@ -57,13 +65,6 @@ def gas_costs(cls) -> GasCosts:
         """
         cpsb = cls.cost_per_state_byte()
         parent = super(EIP8037, cls).gas_costs()
-        # EIP-8037 state byte sizes (EELS amsterdam/vm/gas.py)
-        STATE_BYTES_PER_STORAGE_SET = 64  # noqa: N806
-        STATE_BYTES_PER_NEW_ACCOUNT = 120  # noqa: N806
-        STATE_BYTES_PER_AUTH_BASE = 23  # noqa: N806
-        # EIP-8037 regular gas base costs
-        PER_AUTH_BASE_COST = 7_500  # noqa: N806
-        REGULAR_GAS_CREATE = 9_000  # noqa: N806
         new_acct = STATE_BYTES_PER_NEW_ACCOUNT * cpsb
         return replace(
             parent,
@@ -258,8 +259,6 @@ def transaction_intrinsic_state_gas(
         - Auth: (NEW_ACCOUNT + AUTH_BASE) * cpsb
         """
         cpsb = cls.cost_per_state_byte()
-        STATE_BYTES_PER_NEW_ACCOUNT = 120  # noqa: N806
-        STATE_BYTES_PER_AUTH_BASE = 23  # noqa: N806
         state_gas = 0
         if contract_creation:
             state_gas += STATE_BYTES_PER_NEW_ACCOUNT * cpsb
@@ -324,7 +323,7 @@ def _calculate_sstore_state_gas(
             and current_value != new_value
             and original_value == 0
         ):
-            return 64 * cpsb
+            return STATE_BYTES_PER_STORAGE_SET * cpsb
         return 0
 
     @classmethod
@@ -384,7 +383,7 @@ def _calculate_sstore_state_refund(
         if current_value != new_value:
             if original_value == new_value:
                 if original_value == 0:
-                    return 64 * cpsb
+                    return STATE_BYTES_PER_STORAGE_SET * cpsb
         return 0
 
     @classmethod
@@ -412,9 +411,11 @@ def _calculate_selfdestruct_state_refund(
         ]
         state_refund = 0
         if self_destructed_account:
-            state_refund = 120 * cpsb
+            state_refund = STATE_BYTES_PER_NEW_ACCOUNT * cpsb
             state_refund += (
-                64 * cpsb * self_destructed_account_storage_slot_count
+                STATE_BYTES_PER_STORAGE_SET
+                * cpsb
+                * self_destructed_account_storage_slot_count
             )
             state_refund += cpsb * self_destructed_account_code_deposit
         return state_refund

src/ethereum/forks/amsterdam/vm/eoa_delegation.py

@@ -205,12 +205,9 @@ def set_delegation(message: Message) -> Uint:
         if authority_nonce != auth.nonce:
             continue
 
-        # For existing accounts no account creation happens, so the
-        # NEW_ACCOUNT portion of the auth's intrinsic state cost is
-        # refunded. The reservoir credit lowers `tx_gas_used` for the
-        # sender; debiting `intrinsic_state_gas` lowers
-        # `block_state_gas_used` so the block accounting matches the
-        # state work that actually occurred.
+        # For existing accounts, no account creation needed.
+        # Refund the account creation state gas to the reservoir.
+        # intrinsic_state_gas is immutable after validation.
         if account_exists(tx_state, authority):
             refund = STATE_BYTES_PER_NEW_ACCOUNT * COST_PER_STATE_BYTE
             message.state_gas_reservoir += refund

tests/amsterdam/eip7708_eth_transfer_logs/test_burn_logs.py

@@ -83,6 +83,7 @@ def test_selfdestruct_to_self_same_tx(
     state_test: StateTestFiller,
     env: Environment,
     pre: Alloc,
+    fork: Fork,
     sender: EOA,
     contract_balance: int,
     create_opcode: Op,
@@ -125,7 +126,9 @@ def test_selfdestruct_to_self_same_tx(
         sender=sender,
         to=factory,
         value=contract_balance,
-        gas_limit=300_000,
+        # Same-tx CREATE+SELFDESTRUCT charges NEW_ACCOUNT state gas
+        # under EIP-8037 (0 otherwise).
+        gas_limit=200_000 + fork.gas_costs().NEW_ACCOUNT,
         expected_receipt=TransactionReceipt(logs=expected_logs),
     )
 
@@ -144,6 +147,7 @@ def test_selfdestruct_to_different_address_same_tx(
     state_test: StateTestFiller,
     env: Environment,
     pre: Alloc,
+    fork: Fork,
     sender: EOA,
     contract_balance: int,
     create_opcode: Op,
@@ -189,7 +193,9 @@ def test_selfdestruct_to_different_address_same_tx(
         sender=sender,
         to=factory,
         value=contract_balance,
-        gas_limit=300_000,
+        # Same-tx CREATE+SELFDESTRUCT charges NEW_ACCOUNT state gas
+        # under EIP-8037 (0 otherwise).
+        gas_limit=200_000 + fork.gas_costs().NEW_ACCOUNT,
         expected_receipt=TransactionReceipt(logs=expected_logs),
     )
 
@@ -222,6 +228,7 @@ def test_selfdestruct_same_tx_via_call(
     state_test: StateTestFiller,
     env: Environment,
     pre: Alloc,
+    fork: Fork,
     sender: EOA,
     to_self: bool,
     call_twice: bool,
@@ -303,7 +310,9 @@ def test_selfdestruct_same_tx_via_call(
         sender=sender,
         to=factory,
         value=0,
-        gas_limit=300_000,
+        # CREATE-then-CALL with same-tx SELFDESTRUCT charges
+        # NEW_ACCOUNT state gas under EIP-8037 (0 otherwise).
+        gas_limit=200_000 + fork.gas_costs().NEW_ACCOUNT,
         expected_receipt=TransactionReceipt(logs=expected_logs),
     )
 

tests/amsterdam/eip7708_eth_transfer_logs/test_fork_transition.py

@@ -119,11 +119,14 @@ def test_burn_log_at_fork_transition(
             beneficiary: Account(balance=contract_balance * 3),
         }
 
-    # Same-tx CREATE+SELFDESTRUCT charges NEW_ACCOUNT state gas; the
-    # pre-transition block has plenty of headroom. `fork` is a
-    # TransitionFork here, so resolve to the post-transition fork
-    # (timestamp 15_001) where the larger NEW_ACCOUNT applies.
-    post_fork = fork.fork_at(timestamp=15_001)
+    # `fork` is a TransitionFork here; resolve to the post-transition
+    # fork (where the larger NEW_ACCOUNT applies) so the gas budget
+    # covers the same-tx CREATE+SELFDESTRUCT on the post-transition
+    # block. The pre-transition block has plenty of headroom.
+    pre_transition_timestamp = 14_999
+    transition_timestamp = 15_000
+    post_transition_timestamp = 15_001
+    post_fork = fork.fork_at(timestamp=post_transition_timestamp)
     gas_limit = 200_000 + post_fork.gas_costs().NEW_ACCOUNT
     blocks = [
         Block(
@@ -137,7 +140,13 @@ def test_burn_log_at_fork_transition(
                 )
             ],
         )
-        for i, ts in enumerate([14_999, 15_000, 15_001])
+        for i, ts in enumerate(
+            [
+                pre_transition_timestamp,
+                transition_timestamp,
+                post_transition_timestamp,
+            ]
+        )
     ]
 
     blockchain_test(pre=pre, blocks=blocks, post=post)

tests/amsterdam/eip7708_eth_transfer_logs/test_transfer_logs.py

@@ -1095,16 +1095,20 @@ def test_transfer_with_all_tx_types(
     state_test: StateTestFiller,
     env: Environment,
     pre: Alloc,
+    fork: Fork,
     sender: EOA,
     typed_transaction: Transaction,
 ) -> None:
     """Test that ETH transfers emit logs for all transaction types."""
     recipient = pre.nonexistent_account()
     transfer_amount = 1000
 
+    # Sending value to a nonexistent recipient charges NEW_ACCOUNT
+    # state gas under EIP-8037 (0 otherwise).
     tx = typed_transaction.copy(
         to=recipient,
         value=transfer_amount,
+        gas_limit=typed_transaction.gas_limit + fork.gas_costs().NEW_ACCOUNT,
         expected_receipt=TransactionReceipt(
             logs=[transfer_log(sender, recipient, transfer_amount)]
         ),

tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_cross_index.py

@@ -22,6 +22,7 @@
     BlockchainTestFiller,
     Bytecode,
     Fork,
+    Header,
     Op,
     Transaction,
 )
@@ -275,9 +276,17 @@ def test_bal_noop_write_filtering(
         }
     )
 
+    # Header `gas_used = max(regular, state)` for the single tx; the
+    # SSTORE metadata pins each transition so `regular_cost`/`state_cost`
+    # return the actual fork-priced amount.
+    expected_regular = intrinsic_cost + test_code.regular_cost(fork)
+    expected_state = test_code.state_cost(fork)
     block = Block(
         txs=[tx],
         expected_block_access_list=expected_block_access_list,
+        header_verify=Header(
+            gas_used=max(expected_regular, expected_state),
+        ),
     )
 
     blockchain_test(

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -2466,12 +2466,18 @@ def test_create_collision_burned_gas_counted_in_block_regular(
 
     # CPSB-agnostic baseline: block_state_gas is zero for this tx, so
     # header.gas_used equals the regular-gas total. The forwarded
-    # create_message_gas is `(gas_limit - NEW_ACCOUNT) * 63 // 64`,
-    # plus a CPSB-independent constant covering intrinsic + factory
-    # opcodes. A mutation that drops the burned create_message_gas
-    # from regular accounting would reduce this value.
+    # create_message_gas is `(gas_limit - NEW_ACCOUNT) * 63 // 64`
+    # (the regular gas the inner frame burns on collision); the
+    # remaining cpsb-independent term captures intrinsic + factory
+    # frame regular gas + the parts of CREATE not absorbed by the
+    # 63/64 forwarding split. A mutation that drops the burned
+    # create_message_gas from regular accounting would reduce this
+    # value.
     new_account = fork.gas_costs().NEW_ACCOUNT
-    baseline_gas_used = (gas_limit - new_account) * 63 // 64 + 472
+    cpsb_independent_overhead = 472
+    baseline_gas_used = (
+        gas_limit - new_account
+    ) * 63 // 64 + cpsb_independent_overhead
 
     blockchain_test(
         pre=pre,

tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py

@@ -451,6 +451,7 @@ def test_multi_block_beacon_root_timestamp_calls(
     all_timestamps: List[int] = []
 
     sender = pre.fund_eoa()
+    intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
 
     for timestamp, beacon_root, _i in zip(
         timestamps,
@@ -509,7 +510,6 @@ def test_multi_block_beacon_root_timestamp_calls(
         post[current_call_account_address] = Account(
             storage=current_call_account_expected_storage,
         )
-        intrinsic_calc = fork.transaction_intrinsic_cost_calculator()
         # Bytecode's regular+state cost + N forwarded call_gas envelopes
         # (one per `t` in all_timestamps) + EIP-1706 stipend slack.
         block_gas_limit = (

tests/cancun/eip4844_blobs/test_blobhash_opcode_contexts.py

@@ -313,11 +313,10 @@ def test_blobhash_opcode_contexts(
         case _:
             raise Exception(f"Unknown test case {test_case}")
 
-    # The 500k figure pre-dates EIP-8037 and was empirically chosen to cover
-    # all branches of this test (simple SSTOREs through to CREATE/CREATE2
-    # initcode + deploy). Under EIP-8037 each branch's per-blob SSTOREs add a
-    # `sstore_state_gas()` of state work; bump by that per blob so the budget
-    # remains a precise envelope rather than a rough magic number.
+    # Budget covers all branches (simple SSTOREs, CREATE / CREATE2
+    # initcode + deploy) plus per-blob SSTOREs whose state cost
+    # scales with cpsb under EIP-8037 (`sstore_state_gas()` is 0
+    # otherwise).
     gas_limit = 500_000 + max_blobs_per_tx * fork.sstore_state_gas()
     state_test(
         pre=pre,