feat(spec,test): update bal-devnet-7 EIP-8037 bytes values; CPSB 1174 -> 1530 (#2827)

Author: fselmo

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."""
@@ -28,12 +37,11 @@ def cost_per_state_byte(cls) -> int:
         """
         Return the fixed cost per state byte for EIP-8037.
         """
-        return 1174
+        return 1530
 
     @classmethod
     def sstore_state_gas(cls) -> int:
         """Return state gas for a zero-to-nonzero SSTORE (EIP-8037)."""
-        STATE_BYTES_PER_STORAGE_SET = 32  # 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 = 32  # noqa: N806
-        STATE_BYTES_PER_NEW_ACCOUNT = 112  # 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 = 112  # noqa: N806
-        STATE_BYTES_PER_AUTH_BASE = 23  # noqa: N806
         state_gas = 0
         if contract_creation:
             state_gas += STATE_BYTES_PER_NEW_ACCOUNT * cpsb
@@ -278,7 +277,7 @@ def _calculate_sstore_gas(
         Calculate updated SSTORE gas cost.
 
         For 0->nonzero: regular (UPDATE - COLD_SLOAD) + state
-        (32 * cpsb).
+        (STATE_BYTES_PER_STORAGE_SET * cpsb).
         For nonzero->different nonzero: regular
         (UPDATE - COLD_SLOAD).
         Otherwise: WARM_SLOAD.
@@ -324,7 +323,7 @@ def _calculate_sstore_state_gas(
             and current_value != new_value
             and original_value == 0
         ):
-            return 32 * cpsb
+            return STATE_BYTES_PER_STORAGE_SET * cpsb
         return 0
 
     @classmethod
@@ -368,9 +367,9 @@ def _calculate_sstore_state_refund(
         """
         Calculate SSTORE state gas refund.
 
-        Return the state-gas portion (`32 * cpsb`) when a slot that
-        was originally empty is restored back to zero within the
-        transaction; otherwise return 0.
+        Return the state-gas portion (`STATE_BYTES_PER_STORAGE_SET *
+        cpsb`) when a slot that was originally empty is restored back
+        to zero within the transaction; otherwise return 0.
         """
         del gas_costs
         metadata = opcode.metadata
@@ -384,7 +383,7 @@ def _calculate_sstore_state_refund(
         if current_value != new_value:
             if original_value == new_value:
                 if original_value == 0:
-                    return 32 * cpsb
+                    return STATE_BYTES_PER_STORAGE_SET * cpsb
         return 0
 
     @classmethod
@@ -394,8 +393,9 @@ def _calculate_selfdestruct_state_refund(
         """
         Calculate SELFDESTRUCT state gas refund.
 
-        Account creation: 112 × cost_per_state_byte
-        Created storage slots: 32 × cost_per_state_byte per non-zero slot
+        Account creation: STATE_BYTES_PER_NEW_ACCOUNT × cost_per_state_byte
+        Created storage slots: STATE_BYTES_PER_STORAGE_SET ×
+        cost_per_state_byte per non-zero slot
         Code deposit: len(code) × cost_per_state_byte
         """
         del gas_costs
@@ -411,9 +411,11 @@ def _calculate_selfdestruct_state_refund(
         ]
         state_refund = 0
         if self_destructed_account:
-            state_refund = 112 * cpsb
+            state_refund = STATE_BYTES_PER_NEW_ACCOUNT * cpsb
             state_refund += (
-                32 * 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/gas.py

@@ -26,10 +26,10 @@
 from .exceptions import OutOfGasError
 
 # EIP-8037 state gas accounting constants
-COST_PER_STATE_BYTE = Uint(1174)
+COST_PER_STATE_BYTE = Uint(1530)
 
-STATE_BYTES_PER_NEW_ACCOUNT = Uint(112)
-STATE_BYTES_PER_STORAGE_SET = Uint(32)
+STATE_BYTES_PER_NEW_ACCOUNT = Uint(120)
+STATE_BYTES_PER_STORAGE_SET = Uint(64)
 STATE_BYTES_PER_AUTH_BASE = Uint(23)
 
 PER_AUTH_BASE_COST = Uint(7500)

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=200_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=200_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),
     )
 
@@ -507,7 +516,7 @@ def test_finalization_burn_logs(
         to=None,
         value=0,
         data=factory_code,
-        gas_limit=1_000_000,
+        gas_limit=2_000_000,
         expected_receipt=TransactionReceipt(
             logs=execution_logs + finalization_logs
         ),

tests/amsterdam/eip7708_eth_transfer_logs/test_fork_transition.py

@@ -11,6 +11,7 @@
     Alloc,
     Block,
     BlockchainTestFiller,
+    Fork,
     Op,
     Transaction,
     TransactionReceipt,
@@ -35,6 +36,7 @@
 def test_burn_log_at_fork_transition(
     blockchain_test: BlockchainTestFiller,
     pre: Alloc,
+    fork: Fork,
     same_tx: bool,
     to_self: bool,
 ) -> None:
@@ -117,19 +119,34 @@ def test_burn_log_at_fork_transition(
             beneficiary: Account(balance=contract_balance * 3),
         }
 
+    # `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(
             timestamp=ts,
             txs=[
                 Transaction(
                     to=targets[i],
                     sender=sender,
-                    gas_limit=200_000,
+                    gas_limit=gas_limit,
                     expected_receipt=TransactionReceipt(logs=expected_logs[i]),
                 )
             ],
         )
-        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/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),
     )