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

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

@@ -78,6 +78,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

@@ -221,6 +221,55 @@ 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 gas_limit for a contract-deploy transaction, split
+    into the EIP-7825 cap-bound regular portion and the total
+    (regular + state) deploy gas.
+
+    Per EIP-8037, the per-tx 2^24 cap binds only the regular-gas
+    portion of intrinsic gas; state gas is drawn from the per-block
+    reservoir and may push tx.gas above the cap. We therefore return
+    both values: callers compare ``regular_gas`` against
+    ``transaction_gas_limit_cap()`` and use ``deploy_gas_limit`` as
+    the actual ``tx.gas`` field. Pre-Amsterdam, the state-gas helpers
+    return 0 and ``deploy_gas_limit == regular_gas``.
+
+    The regular portion is doubled as a safety buffer (gas estimation
+    is approximate); the state portion is exact and is not doubled.
+    """
+    gas_costs = fork.gas_costs()
+    memory_expansion_gas_calculator = fork.memory_expansion_gas_calculator()
+    calldata_gas_calculator = fork.calldata_gas_calculator()
+
+    # Regular-gas portion (subject to EIP-7825 cap). On EIP-8037 forks
+    # `TX_CREATE` folds in the new-account state gas; back that out so
+    # we only count regular gas here.
+    regular_gas = gas_costs.TX_BASE + gas_costs.TX_CREATE
+    regular_gas -= fork.transaction_intrinsic_state_gas(contract_creation=True)
+    regular_gas += storage_slots * 22_600
+    regular_gas += deploy_code_size * gas_costs.CODE_DEPOSIT_PER_BYTE
+    regular_gas += memory_expansion_gas_calculator(
+        new_bytes=len(bytes(initcode))
+    )
+    regular_gas += calldata_gas_calculator(data=initcode)
+    regular_gas = regular_gas * 2
+
+    # State-gas portion (drawn from block reservoir, not capped).
+    state_gas = fork.transaction_intrinsic_state_gas(contract_creation=True)
+    state_gas += fork.code_deposit_state_gas(code_size=deploy_code_size)
+    state_gas += storage_slots * Op.SSTORE(new_value=1).state_cost(fork)
+
+    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."""
 
@@ -257,6 +306,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."""
@@ -269,6 +319,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."""
@@ -321,11 +372,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:
@@ -348,18 +394,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
@@ -403,11 +449,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
@@ -443,13 +484,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)}"
@@ -460,14 +498,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)
@@ -476,14 +509,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(
@@ -645,6 +683,7 @@ def _fund_eoa(
                     target=label,
                     to=eoa,
                     value=amount,
+                    gas_limit=self._funding_gas_limit,
                 )
 
         if fund_tx is not None:
@@ -862,6 +901,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:
@@ -876,6 +916,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
 
@@ -985,6 +1026,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)."""
@@ -1009,6 +1051,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
@@ -1034,7 +1077,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

@@ -1167,6 +1167,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

@@ -157,6 +157,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: