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

Author: fselmo

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/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

@@ -2465,12 +2465,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,

tests/common/precompile_fixtures.py

@@ -183,11 +183,9 @@ def tx_gas_limit(fork: Fork, input_data: bytes, precompile_gas: int) -> int:
         fork.transaction_intrinsic_cost_calculator()
     )
     memory_expansion_gas_calculator = fork.memory_expansion_gas_calculator()
-    # `call_contract_code` performs up to 3 SSTOREs (succeeds-flag,
-    # output-length, output-hash) per call. Pre-EIP-8037 each SSTORE
-    # fits comfortably in the 100_000 budget; under EIP-8037 each
-    # SSTORE additionally consumes `fork.sstore_state_gas()` of state
-    # gas, so size the budget against the actual per-fork cost.
+    # `call_contract_code` performs up to 3 SSTOREs per call
+    # (succeeds-flag, output-length, output-hash); under EIP-8037
+    # each adds `sstore_state_gas()` of state work (0 otherwise).
     extra_gas = 100_000 + 3 * fork.sstore_state_gas()
     return (
         extra_gas

tests/constantinople/eip145_bitwise_shift/test_shift_combinations.py

@@ -85,9 +85,9 @@ def test_combinations(
         + Op.STOP,
     )
 
-    # Osaka (EIP-7825) caps tx gas at 16,777,216. Amsterdam (EIP-8037)
-    # lifts the cap and increases SSTORE state gas, needing 25M for
-    # 401 cold zero-to-nonzero SSTOREs (cpsb=1530).
+    # Osaka (EIP-7825) caps tx gas at 16,777,216; Amsterdam
+    # (EIP-8037) lifts that cap and lets state gas fund the test's
+    # ~400 SSTOREs from the reservoir.
     # TODO: auto gas limit will remove this
     gas_limit = 16_000_000
     if fork.is_eip_enabled(8037):

tests/frontier/create/test_create_one_byte.py

@@ -17,7 +17,7 @@
     Transaction,
     compute_create_address,
 )
-from execution_testing.forks import London, Osaka
+from execution_testing.forks import London
 
 
 @pytest.mark.ported_from(
@@ -101,14 +101,16 @@ def test_create_one_byte(
             expect_post[opcode] = created_accounts[opcode]
     expect_post[256] = 1
 
-    # Osaka (EIP-7825) caps transaction gas limit at 16,777,216.
-    # Amsterdam (EIP-8037) adds state gas via the reservoir on top of
-    # the cap. NEW_ACCOUNT and sstore_state_gas are 0 pre-EIP-8037 and
-    # scale with cpsb on Amsterdam, keeping this CPSB-agnostic.
+    # Osaka (EIP-7825) caps transaction gas at
+    # `fork.transaction_gas_limit_cap()`. Amsterdam (EIP-8037) adds
+    # state gas via the reservoir on top of the cap (256 CREATEs and
+    # 257 first-time SSTOREs in this test). Pre-Osaka there's no cap.
+    gas_cap = fork.transaction_gas_limit_cap()
     if fork.is_eip_enabled(8037):
-        gas_limit = 16_000_000 + 256 * new_account + 257 * sstore_state
-    elif fork >= Osaka:
-        gas_limit = 16_000_000
+        assert gas_cap is not None
+        gas_limit = gas_cap + 256 * new_account + 257 * sstore_state
+    elif gas_cap is not None:
+        gas_limit = gas_cap
     else:
         gas_limit = 50_000_000
 

tests/prague/eip7002_el_triggerable_withdrawals/helpers.py

@@ -209,12 +209,15 @@ def transactions(self, fork: Fork | None = None) -> List[Transaction]:
         gas_limit = self.tx_gas_limit
         if fork is not None and fork.is_eip_enabled(8037):
             # Per request the system contract writes 3 entry slots
-            # (source, pubkey, amount); it also bumps a queue tail/count
-            # slot once per call. Cover `3*N + 2` SSTOREs (one tail
-            # slot + one slack slot) of state-set work; the term is 0
-            # pre-EIP-8037 and scales with cpsb on Amsterdam, keeping
-            # this CPSB-agnostic.
-            gas_limit += (len(self.requests) * 3 + 2) * fork.sstore_state_gas()
+            # (source, pubkey, amount); plus a queue-tail bump and
+            # one slot of headroom per tx.
+            sstores_per_request = 3
+            queue_tail_and_slack_sstores = 2
+            sstores = (
+                len(self.requests) * sstores_per_request
+                + queue_tail_and_slack_sstores
+            )
+            gas_limit += sstores * fork.sstore_state_gas()
         return [
             Transaction(
                 gas_limit=gas_limit,