feat(test-specs): Allow automatic transaction gas-limit

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

@@ -11,12 +11,14 @@
 
 from execution_testing.base_types import Account
 from execution_testing.base_types import Alloc as BaseAlloc
+from execution_testing.base_types.base_types import HexNumber
 from execution_testing.execution import BaseExecute
 from execution_testing.forks import Fork, TransitionFork
 from execution_testing.logging import get_logger
 from execution_testing.rpc import EngineRPC, EthRPC
 from execution_testing.specs import BaseTest
 from execution_testing.test_types import (
+    Environment,
     EnvironmentDefaults,
 )
 
@@ -271,6 +273,17 @@ def gas_limit_accumulator() -> Generator[GasInfoAccumulator, None, None]:
     logger.info(f"Total minimum balance: {total_min_eth:.18f}")
 
 
+@pytest.fixture(scope="session")
+def env_gas_limit(eth_rpc: EthRPC) -> HexNumber:
+    """
+    Return the environment gas limit derived from the head block before
+    tests start running.
+    """
+    head_block = eth_rpc.get_block_by_number()
+    assert head_block is not None, "Unable to obtain head block from RPC"
+    return HexNumber(head_block["gasLimit"])
+
+
 def base_test_parametrizer(cls: Type[BaseTest]) -> Any:
     """
     Generate pytest.fixture for a given BaseTest subclass.
@@ -288,7 +301,7 @@ def base_test_parametrizer(cls: Type[BaseTest]) -> Any:
     )
     def base_test_parametrizer_func(
         request: Any,
-        fork: Fork | TransitionFork,
+        fork: Fork,
         pre: Alloc,
         eth_rpc: EthRPC,
         engine_rpc: EngineRPC | None,
@@ -302,6 +315,7 @@ def base_test_parametrizer_func(
         max_fee_per_blob_gas: int,
         max_gas_limit_per_test: int | None,
         gas_limit_accumulator: GasInfoAccumulator,
+        env_gas_limit: HexNumber,
         is_tx_gas_heavy_test: bool,
         is_exception_test: bool,
     ) -> Type[BaseTest]:
@@ -348,24 +362,23 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
                     if p not in kwargs
                 }
 
-                # TODO: get values from network
-                timestamp = 0
-                block_number = 0
-
                 request.node.config.sender_address = str(pre._sender)
 
                 super(BaseTestWrapper, self).__init__(*args, **kwargs)
                 execute = self.execute(execute_format=execute_format)
 
-                # get balances of required sender accounts
-                required_balances = execute.get_required_sender_balances(
+                execute.prepare_transactions(
+                    env=Environment(gas_limit=env_gas_limit),
                     gas_price=gas_price,
                     max_fee_per_gas=max_fee_per_gas,
                     max_priority_fee_per_gas=max_priority_fee_per_gas,
                     max_fee_per_blob_gas=max_fee_per_blob_gas,
-                    fork=fork.fork_at(
-                        block_number=block_number, timestamp=timestamp
-                    ),
+                    fork=fork,
+                )
+
+                # get balances of required sender accounts
+                required_balances = execute.get_required_sender_balances(
+                    fork=fork,
                 )
 
                 pre.resolve_deferred_checks()
@@ -432,9 +445,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
                 )
 
                 execute_result = execute.execute(
-                    fork=fork.fork_at(
-                        block_number=block_number, timestamp=timestamp
-                    ),
+                    fork=fork,
                     eth_rpc=eth_rpc,
                     engine_rpc=engine_rpc,
                     request=request,

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

@@ -978,6 +978,7 @@ def minimum_balance_for_pending_transactions(
                 max_priority_fee_per_gas=max_priority_fee_per_gas,
                 max_fee_per_blob_gas=max_fee_per_blob_gas,
             )
+            assert "gas_limit" in tx.model_fields_set, "tx gas limit not set"
             gas_consumption += tx.gas_limit
             minimum_balance += tx.signer_minimum_balance(fork=fork)
         return minimum_balance + gas_consumption * gas_price, gas_consumption

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

@@ -66,7 +66,7 @@ def pytest_addoption(parser: pytest.Parser) -> None:
 class Alloc(SharedAlloc):
     """Allocation of accounts in the state, pre and post test execution."""
 
-    _eoa_fund_amount_default: int = PrivateAttr(10**21)
+    _eoa_fund_amount_default: int = PrivateAttr(10**27)
     _account_salt: Dict[Hash, int] = PrivateAttr(default_factory=dict)
     _stub_accounts: Dict[str, Account] = PrivateAttr(default_factory=dict)
 

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

@@ -58,13 +58,13 @@ def count_keys_in_fixture(file_path: Path) -> int:  # noqa: D103
     @pytest.mark.valid_until("Shanghai")
     def test_paris_one(state_test) -> None:
         state_test(env=Environment(),
-                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction())
+                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction(gas_limit=0x5208))
 
     @pytest.mark.valid_from("Paris")
     @pytest.mark.valid_until("Shanghai")
     def test_paris_two(state_test) -> None:
         state_test(env=Environment(),
-                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction())
+                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction(gas_limit=0x5208))
     """
 )
 test_count_paris = 4
@@ -79,14 +79,14 @@ def test_paris_two(state_test) -> None:
     @pytest.mark.valid_until("Shanghai")
     def test_shanghai_one(state_test) -> None:
         state_test(env=Environment(),
-                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction())
+                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction(gas_limit=0x5208))
 
     @pytest.mark.parametrize("x", [1, 2, 3])
     @pytest.mark.valid_from("Paris")
     @pytest.mark.valid_until("Shanghai")
     def test_shanghai_two(state_test, x) -> None:
         state_test(env=Environment(),
-                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction())
+                    pre={TestAddress: Account(balance=1_000_000)}, post={}, tx=Transaction(gas_limit=0x5208))
     """
 )
 
@@ -988,7 +988,7 @@ def test_benchmark_one(state_test) -> None:
             env=Environment(),
             pre={TestAddress: Account(balance=1_000_000)},
             post={},
-            tx=Transaction(),
+            tx=Transaction(gas_limit=0x5208),
         )
     """
 )

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

@@ -23,7 +23,7 @@ def test_verify_sync_default(blockchain_test) -> None:
         blockchain_test(
             pre={TestAddress: TEST_ADDRESS},
             post={},
-            blocks=[Block(txs=[Transaction()])]
+            blocks=[Block(txs=[Transaction(gas_limit=0x5208)])]
         )
 
 
@@ -33,7 +33,7 @@ def test_verify_sync_with_marker(blockchain_test) -> None:
         blockchain_test(
             pre={TestAddress: TEST_ADDRESS},
             post={},
-            blocks=[Block(txs=[Transaction()])]
+            blocks=[Block(txs=[Transaction(gas_limit=0x5208)])]
         )
 
     @pytest.mark.valid_at("Cancun")
@@ -52,7 +52,7 @@ def test_verify_sync_with_param_marks(blockchain_test, has_exception) -> None:
             post={},
             blocks=[
                 Block(
-                    txs=[Transaction()],
+                    txs=[Transaction(gas_limit=0x5208)],
                     rlp_modifier=Header(gas_limit=0) if has_exception else None,
                     exception=BlockException.INCORRECT_BLOCK_FORMAT if has_exception else None,
                 )

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

@@ -25,7 +25,6 @@ def type_0_default_transaction(sender: EOA) -> Transaction:
         ty=0,
         sender=sender,
         gas_price=10**9,
-        gas_limit=100_000,
         data=b"\x00" * 100,
         protected=True,
     )
@@ -38,7 +37,6 @@ def type_1_default_transaction(sender: EOA) -> Transaction:
         ty=1,
         sender=sender,
         gas_price=10**9,
-        gas_limit=100_000,
         data=b"\x00" * 100,
         access_list=[
             AccessList(address=0x1234, storage_keys=[0, 1, 2]),
@@ -56,7 +54,6 @@ def type_2_default_transaction(sender: EOA) -> Transaction:
         sender=sender,
         max_fee_per_gas=10**10,
         max_priority_fee_per_gas=10**9,
-        gas_limit=100_000,
         data=b"\x00" * 200,
         access_list=[
             AccessList(address=0x2468, storage_keys=[10, 20, 30]),
@@ -74,7 +71,6 @@ def type_3_default_transaction(sender: EOA) -> Transaction:
         max_fee_per_gas=10**10,
         max_priority_fee_per_gas=10**9,
         max_fee_per_blob_gas=10**9,
-        gas_limit=100_000,
         data=b"\x00" * 150,
         access_list=[
             AccessList(address=0x3690, storage_keys=[100, 200]),
@@ -106,7 +102,6 @@ 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=500_000,
         data=b"\x00" * 200,
         access_list=[
             AccessList(address=0x4567, storage_keys=[1000, 2000, 3000]),

packages/testing/src/execution_testing/execution/base.py

@@ -9,6 +9,7 @@
 from execution_testing.base_types import Address, CamelModel
 from execution_testing.forks import Fork
 from execution_testing.rpc import EngineRPC, EthRPC
+from execution_testing.test_types import Environment
 
 
 class ExecuteResult(CamelModel):
@@ -42,18 +43,32 @@ def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
             # Register the new execute format
             BaseExecute.formats[cls.format_name] = cls
 
-    def get_required_sender_balances(
+    def prepare_transactions(
         self,
         *,
+        env: Environment,
         gas_price: int,
         max_fee_per_gas: int,
         max_priority_fee_per_gas: int,
         max_fee_per_blob_gas: int,
         fork: Fork,
-    ) -> Dict[Address, int]:
-        """Get the required sender balances."""
+    ) -> None:
+        """Prepare transactions by setting their final gas properties."""
+        del env
         del gas_price, max_fee_per_gas, max_priority_fee_per_gas
         del max_fee_per_blob_gas, fork
+        raise Exception(
+            "Method `prepare_transactions` not implemented for "
+            f"{self.format_name}"
+        )
+
+    def get_required_sender_balances(
+        self,
+        *,
+        fork: Fork,
+    ) -> Dict[Address, int]:
+        """Get the required sender balances."""
+        del fork
         raise Exception(
             "Method `get_required_sender_balances` not implemented for "
             f"{self.format_name}"

packages/testing/src/execution_testing/execution/blob_transaction.py

@@ -19,6 +19,7 @@
 )
 from execution_testing.rpc.rpc_types import GetBlobsResponse
 from execution_testing.test_types import (
+    Environment,
     NetworkWrappedTransaction,
     Transaction,
 )
@@ -149,26 +150,50 @@ class BlobTransaction(BaseExecute):
     nonexisting_blob_hashes: List[Hash] | None = None
     get_blobs_version: int | None = None
 
-    def get_required_sender_balances(
+    def prepare_transactions(
         self,
         *,
+        env: Environment,
         gas_price: int,
         max_fee_per_gas: int,
         max_priority_fee_per_gas: int,
         max_fee_per_blob_gas: int,
         fork: Fork,
-    ) -> Dict[Address, int]:
-        """Get the required sender balances."""
-        balances: Dict[Address, int] = {}
+    ) -> None:
+        """Prepare transactions by setting their final gas properties."""
+        txs: List[Transaction] = []
         for tx in self.txs:
-            sender = tx.sender
-            assert sender is not None, "Sender is None"
+            if isinstance(tx, NetworkWrappedTransaction):
+                txs.append(tx.tx)
+            else:
+                txs.append(tx)
+        max_tx_gas_limit = Transaction.calculate_max_gas_limit(
+            txs=txs,
+            env_gas_limit=int(env.gas_limit),
+            transaction_gas_limit_cap=fork.transaction_gas_limit_cap(),
+            state_gas_reservoir_enabled=fork.state_gas_reservoir_enabled(),
+        )
+        for tx in txs:
+            tx.set_gas_limit(
+                max_gas_limit=max_tx_gas_limit,
+                transaction_gas_limit_cap=fork.transaction_gas_limit_cap(),
+                state_gas_reservoir_enabled=fork.state_gas_reservoir_enabled(),
+            )
             tx.set_gas_price(
                 gas_price=gas_price,
                 max_fee_per_gas=max_fee_per_gas,
                 max_priority_fee_per_gas=max_priority_fee_per_gas,
                 max_fee_per_blob_gas=max_fee_per_blob_gas,
             )
+
+    def get_required_sender_balances(
+        self, *, fork: Fork
+    ) -> Dict[Address, int]:
+        """Get the required sender balances."""
+        balances: Dict[Address, int] = {}
+        for tx in self.txs:
+            sender = tx.sender
+            assert sender is not None, "Sender is None"
             if sender not in balances:
                 balances[sender] = 0
             balances[sender] += tx.signer_minimum_balance(fork=fork)

packages/testing/src/execution_testing/execution/transaction_post.py

@@ -14,6 +14,7 @@
     SendTransactionExceptionError,
 )
 from execution_testing.test_types import (
+    Environment,
     NetworkWrappedTransaction,
     TestPhase,
     Transaction,
@@ -39,27 +40,46 @@ class TransactionPost(BaseExecute):
         "are included"
     )
 
-    def get_required_sender_balances(
+    def prepare_transactions(
         self,
         *,
+        env: Environment,
         gas_price: int,
         max_fee_per_gas: int,
         max_priority_fee_per_gas: int,
         max_fee_per_blob_gas: int,
         fork: Fork,
-    ) -> Dict[Address, int]:
-        """Get the required sender balances."""
-        balances: Dict[Address, int] = {}
+    ) -> None:
+        """Prepare transactions by setting their final gas properties."""
         for block in self.blocks:
+            max_tx_gas_limit = Transaction.calculate_max_gas_limit(
+                txs=block,
+                env_gas_limit=int(env.gas_limit),
+                transaction_gas_limit_cap=fork.transaction_gas_limit_cap(),
+                state_gas_reservoir_enabled=fork.state_gas_reservoir_enabled(),
+            )
             for tx in block:
-                sender = tx.sender
-                assert sender is not None, "Sender is None"
+                tx.set_gas_limit(
+                    max_gas_limit=max_tx_gas_limit,
+                    transaction_gas_limit_cap=fork.transaction_gas_limit_cap(),
+                    state_gas_reservoir_enabled=fork.state_gas_reservoir_enabled(),
+                )
                 tx.set_gas_price(
                     gas_price=gas_price,
                     max_fee_per_gas=max_fee_per_gas,
                     max_priority_fee_per_gas=max_priority_fee_per_gas,
                     max_fee_per_blob_gas=max_fee_per_blob_gas,
                 )
+
+    def get_required_sender_balances(
+        self, *, fork: Fork
+    ) -> Dict[Address, int]:
+        """Get the required sender balances."""
+        balances: Dict[Address, int] = {}
+        for block in self.blocks:
+            for tx in block:
+                sender = tx.sender
+                assert sender is not None, "Sender is None"
                 if sender not in balances:
                     balances[sender] = 0
                 balances[sender] += tx.signer_minimum_balance(fork=fork)