chore(test): cleanup / self-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/spec.py

@@ -39,9 +39,9 @@ class Spec:
     # EIP-7825 transaction gas limit cap
     TX_MAX_GAS_LIMIT = 2**24  # 16,777,216
 
-    # TODO: replace with dynamic cost_per_state_byte(gas_limit) once
-    # non-default block gas limits are supported in the test framework.
-    COST_PER_STATE_BYTE = 1530  # at 150M reference block gas limit
+    # CPSB is a fixed parameter derived from a 150M reference block
+    # gas limit and a 120 GiB/year target state growth.
+    COST_PER_STATE_BYTE = 1530
 
     # State bytes per operation
     STATE_BYTES_PER_NEW_ACCOUNT = 120
@@ -52,25 +52,3 @@ class Spec:
     REGULAR_GAS_CREATE = 9000
     PER_AUTH_BASE_COST = 7500
     GAS_COLD_STORAGE_WRITE = 5000
-
-    # EIP-8037 state gas pricing parameters
-    TARGET_STATE_GROWTH_PER_YEAR = 100 * 1024**3
-    BLOCKS_PER_YEAR = 2_628_000
-    COST_PER_STATE_BYTE_SIGNIFICANT_BITS = 5
-    COST_PER_STATE_BYTE_OFFSET = 9578
-
-    @staticmethod
-    def cost_per_state_byte(gas_limit: int) -> int:
-        """Calculate the dynamic state gas cost per byte."""
-        numerator = gas_limit * Spec.BLOCKS_PER_YEAR
-        denominator = 2 * Spec.TARGET_STATE_GROWTH_PER_YEAR
-        raw = (numerator + denominator - 1) // denominator
-        shifted = raw + Spec.COST_PER_STATE_BYTE_OFFSET
-        shift = max(
-            shifted.bit_length() - Spec.COST_PER_STATE_BYTE_SIGNIFICANT_BITS,
-            0,
-        )
-        quantized = (shifted >> shift) << shift
-        if quantized > Spec.COST_PER_STATE_BYTE_OFFSET:
-            return quantized - Spec.COST_PER_STATE_BYTE_OFFSET
-        return 1

tests/amsterdam/eip8037_state_creation_gas_cost_increase/test_state_gas_create.py

@@ -2464,14 +2464,46 @@ def test_create_collision_burned_gas_counted_in_block_regular(
         sender=pre.fund_eoa(),
     )
 
-    # 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.
+    # CPSB-agnostic baseline: block_state_gas is zero for this tx (the
+    # collision refunds the NEW_ACCOUNT state charge), so header.gas_used
+    # equals the regular-gas total. Decompose the parent + inner frame
+    # accounting from fork APIs so the baseline tracks future cost
+    # changes automatically.
+    intrinsic = fork.transaction_intrinsic_cost_calculator()()
     new_account = fork.gas_costs().NEW_ACCOUNT
-    baseline_gas_used = (gas_limit - new_account) * 63 // 64 + 472
+    create_base = fork.gas_costs().OPCODE_CREATE_BASE
+    # POP + STOP run in the parent frame after CREATE returns; their
+    # cost comes out of the 1/64 retained gas.
+    post_create_static = (Op.POP + Op.STOP).gas_cost(fork)
+    # factory_code.gas_cost(fork) folds NEW_ACCOUNT into the CREATE op
+    # (state gas is treated as part of the opcode total). Strip it
+    # back out and split off the post-CREATE tail to isolate the
+    # pre-CREATE static gas.
+    factory_pre_create = (
+        factory_code.gas_cost(fork)
+        - new_account
+        - create_base
+        - post_create_static
+    )
+    # MSTORE writes the initcode at memory[0:32] (one word).
+    memory_expansion = fork.memory_expansion_gas_calculator()(new_bytes=32)
+    # gas_left at the moment NEW_ACCOUNT spills into the regular pool
+    # (reservoir is empty for tx_gas_limit < TX_MAX_GAS_LIMIT).
+    gas_at_create_after_state = (
+        gas_limit
+        - intrinsic
+        - factory_pre_create
+        - memory_expansion
+        - create_base
+        - new_account
+    )
+    # Inner burns 63/64 of the available gas on collision; the parent
+    # retains 1/64. The state-spill of NEW_ACCOUNT is refunded back to
+    # gas_left on collision (nets zero). Post-CREATE consumes from the
+    # retained pool. A mutation that drops the burned forwarded gas
+    # from regular accounting would reduce this baseline.
+    retained = gas_at_create_after_state // 64
+    baseline_gas_used = gas_limit - retained - new_account + post_create_static
 
     blockchain_test(
         pre=pre,