feat(spec-specs, tests): merge EIP-8037 to forks/amsterdam

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/contracts.py

@@ -109,6 +109,7 @@ def deploy_deterministic_factory_contract(
         fund_tx = Transaction(
             to=deploy_tx_sender,
             value=fund_amount,
+            gas_limit=200_000,
             gas_price=gas_price,
             sender=seed_key,
         )

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/execute_recover.py

@@ -24,7 +24,7 @@ def test_recover_funds(
     del index
 
     remaining_balance = eth_rpc.get_balance(eoa)
-    refund_gas_limit = 21_000
+    refund_gas_limit = 200_000
     tx_cost = refund_gas_limit * gas_price
     if remaining_balance < tx_cost:
         pytest.skip(

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/pre_alloc.py

@@ -220,6 +220,58 @@ class _DeferredFundAddress:
     minimum_balance: bool
 
 
+def _compute_deploy_gas_limit(
+    fork: Fork,
+    *,
+    deploy_code_size: int,
+    initcode: Bytes | Initcode,
+    storage_slots: int = 0,
+) -> Tuple[int, int]:
+    """
+    Compute the deploy transaction gas limit, returning both the regular
+    gas portion bound by the EIP 7825 cap and the total regular plus
+    state gas used as the transaction gas field. Under EIP 8037 the cap
+    binds only the regular portion while state gas comes from the block
+    reservoir and may push the total above the cap, and before Amsterdam
+    the state gas is zero so the total equals the regular gas. The regular
+    portion is doubled as a safety buffer since gas estimation is
+    approximate while the state portion is exact.
+    """
+    gas_costs = fork.gas_costs()
+    memory_expansion_gas_calculator = fork.memory_expansion_gas_calculator()
+    intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
+
+    sstore = Op.SSTORE(new_value=1)
+    sstore_state_gas = sstore.state_cost(fork)
+    sstore_regular_gas = sstore.gas_cost(fork) - sstore_state_gas
+
+    # Back out the state gas folded into TX_CREATE.
+    intrinsic_state_gas = fork.transaction_intrinsic_state_gas(
+        contract_creation=True
+    )
+    intrinsic_regular_gas = (
+        intrinsic_gas_calculator(calldata=initcode, contract_creation=True)
+        - intrinsic_state_gas
+    )
+
+    # Regular portion, bound by the gas cap.
+    regular_gas = intrinsic_regular_gas
+    regular_gas += deploy_code_size * gas_costs.CODE_DEPOSIT_PER_BYTE
+    regular_gas += memory_expansion_gas_calculator(
+        new_bytes=len(bytes(initcode))
+    )
+    regular_gas += storage_slots * sstore_regular_gas
+    regular_gas *= 2
+
+    # State portion, from the block reservoir.
+    state_gas = intrinsic_state_gas
+    state_gas += fork.code_deposit_state_gas(code_size=deploy_code_size)
+    state_gas += storage_slots * sstore_state_gas
+
+    deploy_gas_limit = regular_gas + state_gas
+    return regular_gas, deploy_gas_limit
+
+
 class Alloc(SharedAlloc):
     """A custom class that inherits from the original Alloc class."""
 
@@ -256,6 +308,7 @@ def __init__(
         address_stubs: AddressStubs | None = None,
         block_number: int = 0,
         timestamp: int = 0,
+        funding_gas_limit: int = 200_000,
         **kwargs: Any,
     ) -> None:
         """Initialize the pre-alloc with the given parameters."""
@@ -268,6 +321,7 @@ def __init__(
         self._address_stubs = address_stubs or AddressStubs(root={})
         self._block_number = block_number
         self._timestamp = timestamp
+        self._funding_gas_limit = funding_gas_limit
 
     def code_pre_processor(self, code: Bytecode) -> Bytecode:
         """Pre-processes the code before setting it."""
@@ -325,11 +379,6 @@ def _deterministic_deploy_contract(
         fork = self._fork.fork_at(
             block_number=self._block_number, timestamp=self._timestamp
         )
-        gas_costs = fork.gas_costs()
-        memory_expansion_gas_calculator = (
-            fork.memory_expansion_gas_calculator()
-        )
-        calldata_gas_calculator = fork.calldata_gas_calculator()
         if not isinstance(deploy_code, Bytes):
             deploy_code = Bytes(deploy_code)
         if initcode is None:
@@ -352,18 +401,18 @@ def _deterministic_deploy_contract(
             raise ValueError(
                 f"initcode too large {len(initcode)} > {max_initcode_size}"
             )
-        deploy_gas_limit = gas_costs.TX_BASE + gas_costs.TX_CREATE
-        deploy_gas_limit += len(deploy_code) * gas_costs.CODE_DEPOSIT_PER_BYTE
-        deploy_gas_limit += memory_expansion_gas_calculator(
-            new_bytes=len(initcode)
+        regular_gas, deploy_gas_limit = _compute_deploy_gas_limit(
+            fork,
+            deploy_code_size=len(deploy_code),
+            initcode=initcode,
         )
-        deploy_gas_limit += calldata_gas_calculator(data=initcode)
-        deploy_gas_limit = deploy_gas_limit * 2
+        # Per EIP-8037, the per-tx 2^24 cap (EIP-7825) binds only the
+        # regular-gas portion; state gas is drawn from the block reservoir.
         tx_gas_limit_cap = fork.transaction_gas_limit_cap()
-        if tx_gas_limit_cap and deploy_gas_limit > tx_gas_limit_cap:
+        if tx_gas_limit_cap and regular_gas > tx_gas_limit_cap:
             raise ValueError(
-                f"deterministic deploy gas limit exceeds the transaction "
-                f"gas limit cap: {deploy_gas_limit} > {tx_gas_limit_cap}"
+                f"deterministic deploy regular gas exceeds the transaction "
+                f"gas limit cap: {regular_gas} > {tx_gas_limit_cap}"
             )
 
         # Defer the on-chain check; the deploy tx (if needed) and the
@@ -407,11 +456,6 @@ def _deploy_contract(
         fork = self._fork.fork_at(
             block_number=self._block_number, timestamp=self._timestamp
         )
-        gas_costs = fork.gas_costs()
-        memory_expansion_gas_calculator = (
-            fork.memory_expansion_gas_calculator()
-        )
-        calldata_gas_calculator = fork.calldata_gas_calculator()
 
         if not isinstance(storage, Storage):
             storage = Storage(storage)  # type: ignore
@@ -447,13 +491,10 @@ def _deploy_contract(
 
         initcode_prefix = Bytecode()
 
-        deploy_gas_limit = gas_costs.TX_BASE + gas_costs.TX_CREATE
-
         if len(storage.root) > 0:
             initcode_prefix += sum(
                 Op.SSTORE(key, value) for key, value in storage.root.items()
             )
-            deploy_gas_limit += len(storage.root) * 22_600
 
         assert isinstance(code, Bytecode), (
             f"incompatible code type: {type(code)}"
@@ -464,14 +505,9 @@ def _deploy_contract(
         if len(code) > max_code_size:
             raise ValueError(f"code too large: {len(code)} > {max_code_size}")
 
-        deploy_gas_limit += len(code) * gas_costs.CODE_DEPOSIT_PER_BYTE
-
         prepared_initcode = Initcode(
             deploy_code=code, initcode_prefix=initcode_prefix
         )
-        deploy_gas_limit += memory_expansion_gas_calculator(
-            new_bytes=len(bytes(prepared_initcode))
-        )
 
         max_initcode_size = fork.max_initcode_size()
         initcode_len = len(prepared_initcode)
@@ -480,14 +516,19 @@ def _deploy_contract(
                 f"initcode too large {initcode_len} > {max_initcode_size}"
             )
 
-        deploy_gas_limit += calldata_gas_calculator(data=prepared_initcode)
-
-        deploy_gas_limit = deploy_gas_limit * 2
+        regular_gas, deploy_gas_limit = _compute_deploy_gas_limit(
+            fork,
+            deploy_code_size=len(code),
+            initcode=prepared_initcode,
+            storage_slots=len(storage.root),
+        )
+        # Per EIP-8037, the per-tx 2^24 cap (EIP-7825) binds only the
+        # regular-gas portion; state gas is drawn from the block reservoir.
         tx_gas_limit_cap = fork.transaction_gas_limit_cap()
-        if tx_gas_limit_cap and deploy_gas_limit > tx_gas_limit_cap:
+        if tx_gas_limit_cap and regular_gas > tx_gas_limit_cap:
             raise ValueError(
-                f"deploy gas limit exceeds the transaction gas limit cap: "
-                f"{deploy_gas_limit} > {tx_gas_limit_cap}"
+                f"deploy regular gas exceeds the transaction gas limit cap: "
+                f"{regular_gas} > {tx_gas_limit_cap}"
             )
 
         deploy_tx = self._add_pending_tx(
@@ -649,6 +690,7 @@ def _fund_eoa(
                     target=label,
                     to=eoa,
                     value=amount,
+                    gas_limit=self._funding_gas_limit,
                 )
 
         if fund_tx is not None:
@@ -866,6 +908,7 @@ def _resolve_fund_addresses(self) -> None:
                     target=d.address.label,
                     to=d.address,
                     value=d.amount - current_balance,
+                    gas_limit=self._funding_gas_limit,
                 )
                 new_balance = d.amount
             else:
@@ -880,6 +923,7 @@ def _resolve_fund_addresses(self) -> None:
                     target=d.address.label,
                     to=d.address,
                     value=d.amount,
+                    gas_limit=self._funding_gas_limit,
                 )
                 new_balance = current_balance + d.amount
 
@@ -1006,6 +1050,7 @@ def pre(
     max_fee_per_gas: int,
     max_priority_fee_per_gas: int,
     dry_run: bool,
+    sender_fund_refund_gas_limit: int,
     request: pytest.FixtureRequest,
 ) -> Generator[Alloc, None, None]:
     """Return default pre allocation for all tests (Empty alloc)."""
@@ -1030,6 +1075,7 @@ def pre(
         chain_id=chain_config.chain_id,
         node_id=request.node.nodeid,
         address_stubs=address_stubs,
+        funding_gas_limit=sender_fund_refund_gas_limit,
     )
 
     # Yield the pre-alloc for usage during the test
@@ -1055,7 +1101,7 @@ def pre(
     # Build refund transactions
     refund_txs: List[Transaction] = []
     skipped_refunds = 0
-    refund_gas_limit = 21_000
+    refund_gas_limit = sender_fund_refund_gas_limit
     tx_cost = refund_gas_limit * max_fee_per_gas
     for idx, eoa in enumerate(funded_eoas):
         account = eth_rpc.get_account(eoa, skip_code=True)

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/sender.py

@@ -56,7 +56,7 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         action="store",
         dest="sender_fund_refund_gas_limit",
         type=Wei,
-        default=21_000,
+        default=200_000,
         help=(
             "Gas limit set for the funding transactions of each worker's sender key."  # noqa: E501
         ),

packages/testing/src/execution_testing/cli/pytest_commands/plugins/filler/filler.py

@@ -1031,6 +1031,44 @@ def pytest_html_results_table_row(report: Any, cells: Any) -> None:
     del cells[-1]  # Remove the "Links" column
 
 
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_setup(item: Any) -> Generator[None, None, None]:
+    """
+    Snapshot parametrize values before fixture setup to detect unintended
+    mutations of shared pytest parameter objects across fixture format runs.
+    """
+    if hasattr(item, "callspec"):
+        item._param_repr_snapshot = {
+            key: repr(value) for key, value in item.callspec.params.items()
+        }
+    yield
+
+
+def pytest_runtest_teardown(item: Any) -> None:
+    """
+    Compare parametrize values after test teardown to the pre-setup snapshot.
+
+    Warn if any fixture mutated shared parameter objects — these mutations
+    persist across fixture format runs and can cause subtle bugs (e.g.
+    block hash mismatches between blockchain_test and blockchain_engine_test).
+    """
+    snapshot = getattr(item, "_param_repr_snapshot", None)
+    if snapshot is None:
+        return
+    for key, original_repr in snapshot.items():
+        current_repr = repr(item.callspec.params[key])
+        if current_repr != original_repr:
+            warnings.warn(
+                f"Shared pytest parameter '{key}' was mutated during "
+                f"test '{item.nodeid}'. Mutations on parametrize values "
+                f"persist across fixture format runs and can cause "
+                f"divergent test results. Avoid mutating these objects "
+                f"in fixtures; compute derived values locally instead.",
+                stacklevel=1,
+            )
+    del item._param_repr_snapshot
+
+
 @pytest.hookimpl(hookwrapper=True)
 def pytest_runtest_makereport(
     item: Any, call: Any

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

@@ -106,7 +106,7 @@ def type_4_default_transaction(sender: EOA, pre: Alloc) -> Transaction:
         sender=sender,
         max_fee_per_gas=10**10,
         max_priority_fee_per_gas=10**9,
-        gas_limit=150_000,
+        gas_limit=500_000,
         data=b"\x00" * 200,
         access_list=[
             AccessList(address=0x4567, storage_keys=[1000, 2000, 3000]),

packages/testing/src/execution_testing/client_clis/cli_types.py

@@ -158,6 +158,7 @@ class TransactionTraces(CamelModel):
     traces: List[TraceLine]
     output: str | None = None
     gas_used: HexNumber | None = None
+    error: str | None = None
 
     @classmethod
     def from_file(cls, trace_file_path: Path) -> Self: