fix(evm_tools): avoid cloning unchanged fork template in ForkCache (#2738)

* fix(evm_tools): handle GasCosts defaults in template match

* fix(evm_tools): avoid cloning identical fork overrides

* simplify fork cache template stuff

---------

Co-authored-by: Sam Wilson <sam@binarycake.ca>

Author: JackCC703

src/ethereum_spec_tools/evm_tools/t8n/__init__.py

@@ -7,7 +7,8 @@
 import json
 import os
 from contextlib import AbstractContextManager
-from typing import Any, Final, TextIO, Tuple, Type, TypeVar
+from dataclasses import astuple, dataclass
+from typing import Any, Final, TextIO, Type, TypeVar
 
 from ethereum_rlp import rlp
 from ethereum_types.numeric import U64, U256, Uint
@@ -40,6 +41,7 @@
 from .t8n_types import Alloc, Result, Txs
 
 T = TypeVar("T")
+ForkCriteriaArgument = ByBlockNumber | ByTimestamp | Unscheduled | None
 
 
 def t8n_arguments(subparsers: argparse._SubParsersAction) -> None:
@@ -97,12 +99,95 @@ def t8n_arguments(subparsers: argparse._SubParsersAction) -> None:
     t8n_parser.add_argument("--state-test", action="store_true")
 
 
+@dataclass(frozen=True)
+class _ForkOverrides:
+    """Store temporary hardfork override values."""
+
+    fork_criteria: ForkCriteriaArgument = None
+    blob_target_gas_per_block: U64 | None = None
+    gas_per_blob: U64 | None = None
+    blob_min_gasprice: Uint | None = None
+    blob_base_fee_update_fraction: Uint | None = None
+    max_blob_gas_per_block: U64 | None = None
+    blob_schedule_target: U64 | None = None
+    blob_schedule_max: U64 | None = None
+
+    def is_empty(self) -> bool:
+        """Return true when all override values are unset."""
+        return all(value is None for value in astuple(self))
+
+    @staticmethod
+    def _matches_field(override: object | None, on: object, name: str) -> bool:
+        if override is None:
+            return True
+
+        try:
+            default = getattr(on, name)
+        except AttributeError:
+            return False
+
+        return override == default
+
+    def matches_template(
+        self,
+        template: Hardfork,
+    ) -> bool:
+        """Return true when the requested overrides match the template."""
+        if self.is_empty():
+            return True
+
+        if (
+            self.fork_criteria is not None
+            and self.fork_criteria != template.criteria
+        ):
+            return False
+
+        fork_mod = template.module("fork")
+        gas_costs = template.module("vm.gas").GasCosts
+
+        checks = (
+            (
+                self.max_blob_gas_per_block,
+                fork_mod,
+                "MAX_BLOB_GAS_PER_BLOCK",
+            ),
+            (
+                self.blob_target_gas_per_block,
+                gas_costs,
+                "BLOB_TARGET_GAS_PER_BLOCK",
+            ),
+            (self.gas_per_blob, gas_costs, "PER_BLOB"),
+            (
+                self.blob_min_gasprice,
+                gas_costs,
+                "BLOB_MIN_GASPRICE",
+            ),
+            (
+                self.blob_base_fee_update_fraction,
+                gas_costs,
+                "BLOB_BASE_FEE_UPDATE_FRACTION",
+            ),
+            (
+                self.blob_schedule_target,
+                gas_costs,
+                "BLOB_SCHEDULE_TARGET",
+            ),
+            (
+                self.blob_schedule_max,
+                gas_costs,
+                "BLOB_SCHEDULE_MAX",
+            ),
+        )
+
+        return all(self._matches_field(*x) for x in checks)
+
+
 class ForkCache(AbstractContextManager):
     """
     Stores references to temporary hardforks and cleans them up when exited.
     """
 
-    _cache: Final[dict[Tuple[object, ...], TemporaryHardfork]]
+    _cache: Final[dict[tuple[str, _ForkOverrides], TemporaryHardfork]]
 
     def __init__(self) -> None:
         self._cache = {}
@@ -129,35 +214,37 @@ def get(
         Search the cache for a matching hardfork, or create one if it doesn't
         exist.
         """
-        cache_key = (
-            template.short_name,
-            fork_criteria,
-            blob_target_gas_per_block,
-            gas_per_blob,
-            blob_min_gasprice,
-            blob_base_fee_update_fraction,
-            max_blob_gas_per_block,
-            blob_schedule_target,
-            blob_schedule_max,
+        overrides = _ForkOverrides(
+            fork_criteria=fork_criteria,
+            blob_target_gas_per_block=blob_target_gas_per_block,
+            gas_per_blob=gas_per_blob,
+            blob_min_gasprice=blob_min_gasprice,
+            blob_base_fee_update_fraction=blob_base_fee_update_fraction,
+            max_blob_gas_per_block=max_blob_gas_per_block,
+            blob_schedule_target=blob_schedule_target,
+            blob_schedule_max=blob_schedule_max,
         )
-        if all(x is None for x in cache_key[1:]):
+        if overrides.matches_template(template):
             return template
 
+        cache_key = (template.short_name, overrides)
         try:
             return self._cache[cache_key]
         except KeyError:
             pass
 
         clone = Hardfork.clone(
             template=template,
-            fork_criteria=fork_criteria,
-            blob_target_gas_per_block=blob_target_gas_per_block,
-            gas_per_blob=gas_per_blob,
-            blob_min_gasprice=blob_min_gasprice,
-            blob_base_fee_update_fraction=blob_base_fee_update_fraction,
-            max_blob_gas_per_block=max_blob_gas_per_block,
-            blob_schedule_target=blob_schedule_target,
-            blob_schedule_max=blob_schedule_max,
+            fork_criteria=overrides.fork_criteria,
+            blob_target_gas_per_block=overrides.blob_target_gas_per_block,
+            gas_per_blob=overrides.gas_per_blob,
+            blob_min_gasprice=overrides.blob_min_gasprice,
+            blob_base_fee_update_fraction=(
+                overrides.blob_base_fee_update_fraction
+            ),
+            max_blob_gas_per_block=overrides.max_blob_gas_per_block,
+            blob_schedule_target=overrides.blob_schedule_target,
+            blob_schedule_max=overrides.blob_schedule_max,
         )
         self._cache[cache_key] = clone
         return clone