fix(test): more updates related to rigid costs across tests; make flexible

Author: fselmo

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

@@ -104,9 +104,7 @@ def type_4_default_transaction(
     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. NEW_ACCOUNT
-    # is the legacy 25_000 pre-EIP-8037 and scales with cpsb on
-    # Amsterdam, keeping this budget CPSB-agnostic.
+    # log tests), so cover one NEW_ACCOUNT state charge.
     return Transaction(
         ty=4,
         sender=sender,

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

@@ -205,9 +205,12 @@ def set_delegation(message: Message) -> Uint:
         if authority_nonce != auth.nonce:
             continue
 
-        # For existing accounts, no account creation needed.
-        # Refund the account creation state gas to the reservoir.
-        # intrinsic_state_gas is immutable after validation.
+        # 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.
         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_fork_transition.py

@@ -119,11 +119,10 @@ def test_burn_log_at_fork_transition(
             beneficiary: Account(balance=contract_balance * 3),
         }
 
-    # Same-tx CREATE+SELFDESTRUCT requires NEW_ACCOUNT state gas, which
-    # scales with cpsb on Amsterdam. NEW_ACCOUNT is the legacy 25_000
-    # pre-EIP-8037, so the bump is harmless on the pre-transition block.
-    # `fork` is a TransitionFork here; resolve to the post-transition
-    # fork (timestamp 15_001) where the larger NEW_ACCOUNT applies.
+    # 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)
     gas_limit = 200_000 + post_fork.gas_costs().NEW_ACCOUNT
     blocks = [

tests/berlin/eip2930_access_list/test_acl.py

@@ -90,13 +90,16 @@ def test_account_storage_warm_cold_state(
 
     intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
 
+    # CodeGasMeasure SSTOREs the measured cost; budget for one
+    # first-time SSTORE whose state gas scales with cpsb on Amsterdam.
     tx_gas_limit = (
         intrinsic_gas_calculator(
             calldata=tx_data,
             contract_creation=contract_creation,
             access_list=access_lists,
         )
         + 100_000
+        + fork.sstore_state_gas()
     )
 
     tx = Transaction(

tests/cancun/eip5656_mcopy/test_mcopy.py

@@ -11,6 +11,7 @@
     Alloc,
     Bytecode,
     Environment,
+    Fork,
     Hash,
     Op,
     StateTestFiller,
@@ -115,13 +116,20 @@ def code_address(pre: Alloc, code_bytecode: Bytecode) -> Address:
 
 @pytest.fixture
 def tx(  # noqa: D103
-    pre: Alloc, code_address: Address, dest: int, src: int, length: int
+    pre: Alloc,
+    fork: Fork,
+    code_address: Address,
+    dest: int,
+    src: int,
+    length: int,
 ) -> Transaction:
+    # The test SSTOREs each memory word it reads, so budget for ~10
+    # first-time SSTOREs whose state gas scales with cpsb on Amsterdam.
     return Transaction(
         sender=pre.fund_eoa(),
         to=code_address,
         data=Hash(dest) + Hash(src) + Hash(length),
-        gas_limit=1_000_000,
+        gas_limit=1_000_000 + 10 * fork.sstore_state_gas(),
     )
 
 
@@ -231,6 +239,7 @@ def test_valid_mcopy_operations(
 def test_mcopy_repeated(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
     dest: int,
     src: int,
     length: int,
@@ -294,7 +303,7 @@ def test_mcopy_repeated(
             sender=pre.fund_eoa(),
             to=contract,
             data=Hash(dest) + Hash(src) + Hash(length),
-            gas_limit=1_000_000,
+            gas_limit=1_000_000 + 2 * fork.sstore_state_gas(),
         ),
     )
 

tests/cancun/eip6780_selfdestruct/test_selfdestruct.py

@@ -1632,6 +1632,7 @@ def test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx(
     blockchain_test: BlockchainTestFiller,
     eip_enabled: bool,
     pre: Alloc,
+    fork: Fork,
     sender: EOA,
     selfdestruct_contract_initial_balance: int,
 ) -> None:
@@ -1734,16 +1735,21 @@ def test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx(
         + Op.STOP
     )
 
+    # tx1 does 2 CREATE2 (NEW_ACCOUNT each) plus several first-time
+    # SSTOREs across entry/init code; tx2 does one SSTORE call.
+    # Bump scales with cpsb on Amsterdam.
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
     txs = [
         Transaction(
             sender=sender,
             to=entry_code_address,
-            gas_limit=1_000_000,
+            gas_limit=1_000_000 + 2 * new_account + 6 * sstore_state,
         ),
         Transaction(
             sender=sender,
             to=tx2_caller,
-            gas_limit=500_000,
+            gas_limit=500_000 + sstore_state,
         ),
     ]
 

tests/constantinople/eip1014_create2/test_create2_revert.py

@@ -7,6 +7,7 @@
     Account,
     Alloc,
     Environment,
+    Fork,
     Initcode,
     Op,
     StateTestFiller,
@@ -87,6 +88,7 @@ def test_create2_revert_preserves_balance(
 def test_create2_succeeds_after_reverted_create2(
     state_test: StateTestFiller,
     pre: Alloc,
+    fork: Fork,
 ) -> None:
     """
     Test that CREATE2 succeeds after a previous CREATE2 at the same address
@@ -99,6 +101,9 @@ def test_create2_succeeds_after_reverted_create2(
     storage = Storage()
     salt = 1
 
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
+
     runtime_code = Op.SSTORE(0, 1) + Op.STOP
     initcode = Initcode(deploy_code=runtime_code)
 
@@ -129,7 +134,7 @@ def test_create2_succeeds_after_reverted_create2(
         Op.CALLDATACOPY(0, 0, Op.CALLDATASIZE)
         + Op.POP(
             Op.CALL(
-                gas=200_000,
+                gas=200_000 + new_account + sstore_state,
                 address=creator,
                 args_size=Op.CALLDATASIZE,
             )
@@ -144,7 +149,7 @@ def test_create2_succeeds_after_reverted_create2(
         + Op.SSTORE(
             storage.store_next(0, "reverter_call_result"),
             Op.CALL(
-                gas=300_000,
+                gas=300_000 + new_account + sstore_state,
                 address=reverter,
                 args_size=Op.CALLDATASIZE,
             ),
@@ -153,7 +158,7 @@ def test_create2_succeeds_after_reverted_create2(
         + Op.SSTORE(
             storage.store_next(1, "creator_call_result"),
             Op.CALL(
-                gas=300_000,
+                gas=300_000 + new_account + sstore_state,
                 address=creator,
                 args_size=Op.CALLDATASIZE,
             ),
@@ -177,7 +182,7 @@ def test_create2_succeeds_after_reverted_create2(
         tx=Transaction(
             sender=sender,
             to=outer,
-            gas_limit=2_000_000,
+            gas_limit=2_000_000 + 2 * (new_account + sstore_state),
             data=initcode,
         ),
     )

tests/constantinople/eip1052_extcodehash/test_extcodehash.py

@@ -563,9 +563,12 @@ def test_extcodehash_dynamic_account_overwrite(
     target_storage[target_storage_slot] = 1
 
     sender = pre.fund_eoa()
-    gas_limit = 400_000
-    if fork.is_eip_enabled(8037):
-        gas_limit = 1_000_000
+    # Test does ~10 first-time SSTOREs plus a CREATE2 (NEW_ACCOUNT)
+    # in the caller. Both terms are 0 pre-EIP-8037 and scale with cpsb
+    # on Amsterdam, keeping this CPSB-agnostic.
+    gas_limit = (
+        400_000 + fork.gas_costs().NEW_ACCOUNT + 10 * fork.sstore_state_gas()
+    )
 
     tx = Transaction(
         sender=sender,
@@ -1352,19 +1355,22 @@ def test_extcodehash_call_to_selfdestruct(
 
     call_succeeds = call_opcode != Op.STATICCALL
 
+    # SELFDESTRUCT to a nonexistent beneficiary creates a new account
+    # whose state gas scales with cpsb on Amsterdam. Forward enough so
+    # the inner CALL still completes when NEW_ACCOUNT grows.
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
     code = Op.SSTORE(
         storage.store_next(int(call_succeeds)),
-        call_opcode(address=target, gas=165_000),
+        call_opcode(address=target, gas=165_000 + new_account),
     ) + Op.SSTORE(
         storage.store_next(target_code.keccak256()),
         Op.EXTCODEHASH(target),
     )
 
     code_address = pre.deploy_contract(code, storage=storage.canary())
 
-    gas_limit = 400_000
-    if fork.is_eip_enabled(8037):
-        gas_limit = 1_000_000
+    gas_limit = 400_000 + new_account + 2 * sstore_state
     tx = Transaction(
         sender=pre.fund_eoa(),
         to=code_address,
@@ -1578,9 +1584,11 @@ def inner_extcode_checks() -> Bytecode:
     )
     outer = pre.deploy_contract(outer_code, storage=outer_storage.canary())
 
-    gas_limit = 400_000
-    if fork.is_eip_enabled(8037):
-        gas_limit = 1_000_000
+    # Test does ~10 first-time SSTOREs (across inner and outer) plus a
+    # CREATE2 (NEW_ACCOUNT). Both terms scale with cpsb on Amsterdam.
+    gas_limit = (
+        400_000 + fork.gas_costs().NEW_ACCOUNT + 10 * fork.sstore_state_gas()
+    )
     tx = Transaction(
         sender=pre.fund_eoa(),
         to=outer,
@@ -1639,9 +1647,14 @@ def test_extcodehash_subcall_selfdestruct(
     selfdestruct_code = Op.SELFDESTRUCT(beneficiary)
     target_c = pre.deploy_contract(selfdestruct_code)
 
+    # SELFDESTRUCT to a nonexistent beneficiary creates a new account
+    # whose state gas scales with cpsb on Amsterdam.
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
+
     # A: executes C's code in A's context via CALLCODE/DELEGATECALL
     a_code = call_opcode(
-        gas=350_000,
+        gas=350_000 + new_account,
         address=target_c,
         ret_size=32,
     )
@@ -1682,12 +1695,12 @@ def extcode_checks(target: Address | Bytecode) -> Bytecode:
     code += extcode_checks(a_target)
     code += Op.SSTORE(
         storage.store_next(1),
-        Op.CALL(gas=350_000, address=a_target),
+        Op.CALL(gas=350_000 + new_account, address=a_target),
     )
     code += extcode_checks(a_target)
     code += Op.SSTORE(
         storage.store_next(1),
-        Op.CALL(gas=350_000, address=a_target),
+        Op.CALL(gas=350_000 + new_account, address=a_target),
     )
 
     code_address = pre.deploy_contract(code, storage=storage.canary())
@@ -1696,9 +1709,8 @@ def extcode_checks(target: Address | Bytecode) -> Bytecode:
         a = compute_create_address(address=code_address, nonce=1)
         storage[created_slot] = a
 
-    gas_limit = 500_000
-    if fork.is_eip_enabled(8037):
-        gas_limit = 1_000_000
+    # Test does up to ~7 first-time SSTOREs plus a CREATE for dynamic A.
+    gas_limit = 500_000 + new_account + 7 * sstore_state
     tx = Transaction(
         sender=pre.fund_eoa(),
         to=code_address,
@@ -1757,6 +1769,12 @@ def test_extcodehash_subcall_create2_oog(
     deploy_code_bytes = bytes(deploy_code)
     initcode = Initcode(deploy_code=deploy_code)
 
+    # CREATE2 charges NEW_ACCOUNT state gas; the deploy_code's SSTORE
+    # also charges first-time SSTORE state gas. Both scale with cpsb
+    # on Amsterdam.
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
+
     # Factory: CREATE2, optionally consume all gas to trigger OOG.
     factory_code = Om.MSTORE(initcode, 0) + Op.MSTORE(
         0, Op.CREATE2(value=0, offset=0, size=len(initcode), salt=0)
@@ -1777,7 +1795,7 @@ def test_extcodehash_subcall_create2_oog(
             storage.store_next(int(not oog), "call_result"),
             call_opcode(
                 address=factory,
-                gas=200_000,
+                gas=200_000 + new_account + sstore_state,
                 ret_offset=0,
                 ret_size=32,
             ),
@@ -1813,9 +1831,8 @@ def test_extcodehash_subcall_create2_oog(
     else:
         post[created] = Account(nonce=1, code=deploy_code)
 
-    gas_limit = 500_000
-    if fork.is_eip_enabled(8037):
-        gas_limit = 1_000_000
+    # Caller does ~5 first-time SSTOREs plus the inner CALL+CREATE2.
+    gas_limit = 500_000 + new_account + 5 * sstore_state
     tx = Transaction(
         sender=pre.fund_eoa(),
         to=code_address,

tests/frontier/create/test_create_one_byte.py

@@ -48,9 +48,11 @@ def test_create_one_byte(
     sender = pre.fund_eoa()
     expect_post = Storage()
 
-    call_gas = 50_000
-    if fork.is_eip_enabled(8037):
-        call_gas = 200_000
+    new_account = fork.gas_costs().NEW_ACCOUNT
+    sstore_state = fork.sstore_state_gas()
+    # Each call forwards gas to the create_contract that does CREATE;
+    # forward base + NEW_ACCOUNT (cpsb-agnostic).
+    call_gas = 50_000 + new_account
 
     # make a subcontract that deploys code, because deploy 0xef eats ALL gas
     create_contract = pre.deploy_contract(
@@ -100,9 +102,11 @@ def test_create_one_byte(
     expect_post[256] = 1
 
     # Osaka (EIP-7825) caps transaction gas limit at 16,777,216.
-    # Amsterdam (EIP-8037) adds state gas for CREATEs and SSTOREs.
+    # 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.
     if fork.is_eip_enabled(8037):
-        gas_limit = 60_000_000
+        gas_limit = 16_000_000 + 256 * new_account + 257 * sstore_state
     elif fork >= Osaka:
         gas_limit = 16_000_000
     else:

tests/frontier/identity_precompile/conftest.py

@@ -1,9 +1,13 @@
 """Pytest (plugin) definitions local to Identity precompile tests."""
 
 import pytest
+from execution_testing import Fork
 
 
 @pytest.fixture
-def tx_gas_limit() -> int:
+def tx_gas_limit(fork: Fork) -> int:
     """Return the gas limit for transactions."""
-    return 365_224
+    # The `nonzerovalue` variants transfer 1 wei to the identity
+    # precompile, creating its account and charging NEW_ACCOUNT
+    # state gas under EIP-8037 (0 otherwise).
+    return 365_224 + fork.gas_costs().NEW_ACCOUNT