feat(spec-tools): Support dynamic BPO forks

Author: SamWilsn

packages/testing/src/execution_testing/client_clis/clis/execution_specs.py

@@ -7,10 +7,11 @@
 from io import StringIO
 from pathlib import Path
 from typing import Any, ClassVar, Dict, Optional
+from typing_extensions import override
 
 import ethereum
 from ethereum_spec_tools.evm_tools import create_parser
-from ethereum_spec_tools.evm_tools.t8n import T8N
+from ethereum_spec_tools.evm_tools.t8n import T8N, ForkCache
 from ethereum_spec_tools.evm_tools.utils import get_supported_forks
 
 from execution_testing.client_clis.cli_types import TransitionToolOutput
@@ -33,6 +34,9 @@
 class ExecutionSpecsTransitionTool(TransitionTool):
     """Implementation of the EELS T8N for execution-spec-tests."""
 
+    supports_opcode_count: ClassVar[bool] = True
+    supports_blob_params: ClassVar[bool] = True
+
     def __init__(
         self,
         *,
@@ -44,6 +48,11 @@ def __init__(
         self.exception_mapper = ExecutionSpecsExceptionMapper()
         self.trace = trace
         self._info_metadata: Optional[Dict[str, Any]] = {}
+        self.fork_cache = ForkCache()
+
+    @override
+    def shutdown(self) -> None:
+        self.fork_cache.__exit__()
 
     def version(self) -> str:
         """Version of the t8n tool."""
@@ -87,6 +96,9 @@ def evaluate(
         if transition_tool_data.state_test:
             t8n_args.append("--state-test")
 
+        if transition_tool_data.blob_params:
+            t8n_args.append("--input.blobParams=stdin")
+
         if self.trace:
             t8n_args.extend(
                 [
@@ -103,7 +115,7 @@ def evaluate(
 
         in_stream = StringIO(json.dumps(request_data_json["input"]))
 
-        t8n = T8N(t8n_options, out_stream, in_stream)
+        t8n = T8N(t8n_options, out_stream, in_stream, self.fork_cache)
         t8n.run()
 
         output_dict = json.loads(out_stream.getvalue())

src/ethereum_spec_tools/evm_tools/__init__.py

@@ -5,14 +5,15 @@
 import argparse
 import subprocess
 import sys
+from contextlib import ExitStack
 from typing import Optional, Sequence, Text, TextIO
 
 from ethereum import __version__
 
 from .b11r import B11R, b11r_arguments
 from .daemon import Daemon, daemon_arguments
 from .statetest import StateTest, state_test_arguments
-from .t8n import T8N, t8n_arguments
+from .t8n import T8N, ForkCache, t8n_arguments
 from .utils import get_supported_forks
 
 DESCRIPTION = """
@@ -90,6 +91,7 @@ def main(
     args: Optional[Sequence[Text]] = None,
     out_file: Optional[TextIO] = None,
     in_file: Optional[TextIO] = None,
+    fork_cache: Optional[ForkCache] = None,
 ) -> int:
     """Run the tools based on the given options."""
     parser = create_parser()
@@ -102,18 +104,23 @@ def main(
     if in_file is None:
         in_file = sys.stdin
 
-    if options.evm_tool == "t8n":
-        t8n_tool = T8N(options, out_file, in_file)
-        return t8n_tool.run()
-    elif options.evm_tool == "b11r":
-        b11r_tool = B11R(options, out_file, in_file)
-        return b11r_tool.run()
-    elif options.evm_tool == "daemon":
-        daemon = Daemon(options)
-        return daemon.run()
-    elif options.evm_tool == "statetest":
-        state_test = StateTest(options, out_file, in_file)
-        return state_test.run()
-    else:
-        parser.print_help(file=out_file)
-        return 0
+    with ExitStack() as exit_stack:
+        if fork_cache is None:
+            fork_cache = ForkCache()
+            exit_stack.push(fork_cache)
+
+        if options.evm_tool == "t8n":
+            t8n_tool = T8N(options, out_file, in_file, fork_cache)
+            return t8n_tool.run()
+        elif options.evm_tool == "b11r":
+            b11r_tool = B11R(options, out_file, in_file)
+            return b11r_tool.run()
+        elif options.evm_tool == "daemon":
+            daemon = Daemon(options)
+            return daemon.run()
+        elif options.evm_tool == "statetest":
+            state_test = StateTest(options, out_file, in_file)
+            return state_test.run()
+        else:
+            parser.print_help(file=out_file)
+            return 0

src/ethereum_spec_tools/evm_tools/loaders/fork_loader.py

@@ -2,6 +2,7 @@
 Loader for code from the relevant fork.
 """
 
+from inspect import signature
 from typing import Any, Final
 
 from ethereum_spec_tools.forks import Hardfork
@@ -28,28 +29,16 @@ def proof_of_stake(self) -> bool:
         """Whether the fork is proof of stake."""
         return self.hardfork.consensus.is_pos()
 
-    def is_after_fork(self, target_fork_name: str) -> bool:
-        """
-        Check if the fork is after the target fork.
-
-        Accepts short fork names (e.g. "cancun") instead of full module paths.
-        """
-        target_fork: Hardfork | None = None
-        for fork in self._forks:
-            if fork.short_name == target_fork_name:
-                target_fork = fork
-                break
-
-        if target_fork is None:
-            raise Exception(f"fork `{target_fork_name}` not found")
-
-        return self.hardfork.mod.FORK_CRITERIA >= target_fork.mod.FORK_CRITERIA
-
     @property
     def BEACON_ROOTS_ADDRESS(self) -> Any:
         """BEACON_ROOTS_ADDRESS of the given fork."""
         return self._module("fork").BEACON_ROOTS_ADDRESS
 
+    @property
+    def has_beacon_roots_address(self) -> bool:
+        """Check if the fork has a `BEACON_ROOTS_ADDRESS` constant."""
+        return hasattr(self._module("fork"), "BEACON_ROOTS_ADDRESS")
+
     @property
     def HISTORY_STORAGE_ADDRESS(self) -> Any:
         """HISTORY_STORAGE_ADDRESS of the given fork."""
@@ -80,11 +69,22 @@ def calculate_block_difficulty(self) -> Any:
         """calculate_block_difficulty function of the given fork."""
         return self._module("fork").calculate_block_difficulty
 
+    @property
+    def calculate_block_difficulty_arity(self) -> int:
+        """Number of parameters required by `calculate_block_difficulty`."""
+        inspected = signature(self._module("fork").calculate_block_difficulty)
+        return len(inspected.parameters)
+
     @property
     def calculate_base_fee_per_gas(self) -> Any:
         """calculate_base_fee_per_gas function of the given fork."""
         return self._module("fork").calculate_base_fee_per_gas
 
+    @property
+    def has_calculate_base_fee_per_gas(self) -> bool:
+        """Check if the fork has a `calculate_base_fee_per_gas` function."""
+        return hasattr(self._module("fork"), "calculate_base_fee_per_gas")
+
     @property
     def logs_bloom(self) -> Any:
         """logs_bloom function of the given fork."""
@@ -115,6 +115,11 @@ def signing_hash_155(self) -> Any:
         """signing_hash_155 function of the fork."""
         return self._module("transactions").signing_hash_155
 
+    @property
+    def has_signing_hash_155(self) -> bool:
+        """Check if the fork has a `signing_hash_155` function."""
+        return hasattr(self._module("transactions"), "signing_hash_155")
+
     @property
     def signing_hash_2930(self) -> Any:
         """signing_hash_2930 function of the fork."""
@@ -160,6 +165,15 @@ def compute_requests_hash(self) -> Any:
         """compute_requests_hash function of the fork."""
         return self._module("requests").compute_requests_hash
 
+    @property
+    def has_compute_requests_hash(self) -> bool:
+        """Check if the fork has a `has_requests_hash` function."""
+        try:
+            module = self._module("requests")
+        except ModuleNotFoundError:
+            return False
+        return hasattr(module, "compute_requests_hash")
+
     @property
     def Bloom(self) -> Any:
         """Bloom class of the fork."""
@@ -190,6 +204,14 @@ def LegacyTransaction(self) -> Any:
         """Legacytransaction class of the fork."""
         return self._module("transactions").LegacyTransaction
 
+    @property
+    def has_legacy_transaction(self) -> bool:
+        """
+        Return `True` if the fork has a `LegacyTransaction` class, or `False`
+        otherwise.
+        """
+        return hasattr(self._module("transactions"), "LegacyTransaction")
+
     @property
     def Access(self) -> Any:
         """Access class of the fork."""
@@ -220,11 +242,21 @@ def Withdrawal(self) -> Any:
         """Withdrawal class of the fork."""
         return self._module("blocks").Withdrawal
 
+    @property
+    def has_withdrawal(self) -> bool:
+        """Check if the fork has a `Withdrawal` class."""
+        return hasattr(self._module("blocks"), "Withdrawal")
+
     @property
     def decode_transaction(self) -> Any:
         """decode_transaction function of the fork."""
         return self._module("transactions").decode_transaction
 
+    @property
+    def has_decode_transaction(self) -> bool:
+        """Check if this fork has a `decode_transaction`."""
+        return hasattr(self._module("transactions"), "decode_transaction")
+
     @property
     def State(self) -> Any:
         """State class of the fork."""

src/ethereum_spec_tools/evm_tools/statetest/__init__.py

@@ -13,7 +13,7 @@
 
 from ethereum.utils.hexadecimal import hex_to_bytes
 
-from ..t8n import T8N
+from ..t8n import T8N, ForkCache
 from ..t8n.t8n_types import Result
 from ..utils import get_supported_forks
 
@@ -84,6 +84,7 @@ def read_test_cases(test_file_path: str) -> Iterable[TestCase]:
 
 def run_test_case(
     test_case: TestCase,
+    fork_cache: ForkCache,
     t8n_extra: Optional[List[str]] = None,
     output_basedir: Optional[str | TextIO] = None,
 ) -> Result:
@@ -155,7 +156,7 @@ def run_test_case(
     if output_basedir is not None:
         t8n_options.output_basedir = output_basedir
 
-    t8n = T8N(t8n_options, out_stream, in_stream)
+    t8n = T8N(t8n_options, out_stream, in_stream, fork_cache)
     t8n.run_state_test()
     return t8n.result
 
@@ -221,12 +222,13 @@ def run(self) -> int:
         stream_handler.setFormatter(formatter)
         logger.addHandler(stream_handler)
 
-        if self.file is None:
-            return self.run_many()
-        else:
-            return self.run_one(self.file)
+        with ForkCache() as fork_cache:
+            if self.file is None:
+                return self.run_many(fork_cache)
+            else:
+                return self.run_one(self.file, fork_cache)
 
-    def run_one(self, path: str) -> int:
+    def run_one(self, path: str, fork_cache: ForkCache) -> int:
         """
         Execute state tests from a single file.
         """
@@ -255,6 +257,7 @@ def run_one(self, path: str) -> int:
 
             result = run_test_case(
                 test_case,
+                fork_cache,
                 t8n_extra=t8n_extra,
                 output_basedir=sys.stderr,
             )
@@ -288,13 +291,13 @@ def run_one(self, path: str) -> int:
         self.out_file.write("\n")
         return 0
 
-    def run_many(self) -> int:
+    def run_many(self, fork_cache: ForkCache) -> int:
         """
         Execute state tests from a line-delimited list of files provided from
         `self.in_file`.
         """
         for line in self.in_file:
-            result = self.run_one(line[:-1])
+            result = self.run_one(line[:-1], fork_cache)
             if result != 0:
                 return result
         return 0