fix(test-forks): treat transition fork variants as equal to canonical (ethereum#2782)

* test(test-forks): add failing test for transition fork variant equality

Cover the case where `with_env_gas_limit` variants of a transition fork
compare unequal to their canonical class and to each other, breaking
pre-alloc group reuse during fill.

* fix(test-forks): treat transition fork variants as equal to canonical

`TransitionBaseClass.with_env_gas_limit` produced new class objects that
compared unequal via the default `type.__eq__`, breaking pre-alloc group
reuse during fill (assertion in `add_test_pre`).

Mirror `BaseForkMeta` by adding `__eq__`/`__hash__` on
`TransitionBaseMetaClass` keyed on the canonical identity, and set
`_base_fork` on the variant inside `with_env_gas_limit`. Widen
`_identity`/`_maybe_transitioned` signatures to `type` so the metaclass
can reuse them.

Author: danceratopz

packages/testing/src/execution_testing/forks/base_fork.py

@@ -184,7 +184,7 @@ def __repr__(cls) -> str:
         return cls.name()
 
     @staticmethod
-    def _maybe_transitioned(fork_cls: "BaseForkMeta") -> "BaseForkMeta":
+    def _maybe_transitioned(fork_cls: type) -> type:
         """
         Return the transitioned fork, if a transition fork, otherwise return
         `fork_cls`.
@@ -203,14 +203,14 @@ def _is_subclass_of(a: "BaseForkMeta", b: "BaseForkMeta") -> bool:
         """
         # Resolve variants to canonical identity so comparisons between
         # a variant and a canonical descendant fork work as expected.
-        a = BaseForkMeta._identity(a)
-        b = BaseForkMeta._identity(b)
-        a = BaseForkMeta._maybe_transitioned(a)
-        b = BaseForkMeta._maybe_transitioned(b)
-        return issubclass(a, b)
+        a_id: type = BaseForkMeta._identity(a)
+        b_id: type = BaseForkMeta._identity(b)
+        a_id = BaseForkMeta._maybe_transitioned(a_id)
+        b_id = BaseForkMeta._maybe_transitioned(b_id)
+        return issubclass(a_id, b_id)
 
     @staticmethod
-    def _identity(fork_cls: "BaseForkMeta") -> "BaseForkMeta":
+    def _identity(fork_cls: type) -> type:
         """Return the canonical fork class, resolving variants."""
         base = getattr(fork_cls, "_base_fork", None)
         return base if base is not None else fork_cls

packages/testing/src/execution_testing/forks/tests/test_forks.py

@@ -754,3 +754,32 @@ def test_fork_variant_ordering() -> None:
     assert not (variant < London)
     assert variant >= London
     assert variant <= London
+
+
+def test_transition_fork_variant_equality() -> None:
+    """
+    Variants of a transition fork created via `with_env_gas_limit` must
+    compare equal to their canonical parent and to each other, even when
+    different gas limits are used. Distinct canonical transition forks
+    must remain unequal.
+    """
+    canonical = CancunToPragueAtTime15k
+    variant_a = canonical.with_env_gas_limit(30_000_000)
+    variant_b = canonical.with_env_gas_limit(45_000_000)
+    variant_c = canonical.with_env_gas_limit(30_000_000)
+
+    assert variant_a is not canonical
+    assert variant_a is not variant_b
+    assert variant_a is not variant_c
+
+    assert variant_a == canonical
+    assert variant_b == canonical
+    assert variant_a == variant_b
+    assert variant_a == variant_c
+
+    assert hash(variant_a) == hash(canonical)
+    assert hash(variant_b) == hash(canonical)
+    assert hash(variant_c) == hash(canonical)
+
+    assert canonical != PragueToOsakaAtTime15k
+    assert variant_a != PragueToOsakaAtTime15k

packages/testing/src/execution_testing/forks/transition_base_fork.py

@@ -1,8 +1,8 @@
 """Base objects used to define transition forks."""
 
-from typing import Any, Callable, ClassVar, Dict, Type
+from typing import Any, Callable, ClassVar, Dict, Optional, Type
 
-from .base_fork import BaseFork
+from .base_fork import BaseFork, BaseForkMeta
 
 
 class TransitionBaseMetaClass(type):
@@ -15,6 +15,19 @@ def name(cls) -> str:
         """
         raise Exception("Not implemented")
 
+    def __eq__(cls, other: object) -> bool:
+        """
+        Compare transition fork identity, treating variants created by
+        `with_env_gas_limit` as equal to their canonical parent.
+        """
+        if not isinstance(other, type):
+            return NotImplemented
+        return BaseForkMeta._identity(cls) is BaseForkMeta._identity(other)
+
+    def __hash__(cls) -> int:
+        """Hash by canonical transition fork identity."""
+        return id(BaseForkMeta._identity(cls))
+
     def transitions_to(cls) -> Type[BaseFork]:
         """
         Return fork where the transition ends.
@@ -76,6 +89,7 @@ class TransitionBaseClass(metaclass=TransitionBaseMetaClass):
     at_timestamp: ClassVar[int] = 0
     _ignore: ClassVar[bool] = False
     _env_gas_limit: ClassVar[int] = 0
+    _base_fork: ClassVar[Optional[Type["TransitionBaseClass"]]] = None
 
     @classmethod
     def fork_at(
@@ -117,6 +131,7 @@ def with_env_gas_limit(
         """
         new_cls = type(cls.__name__, (cls,), {})
         new_cls._env_gas_limit = env_gas_limit  # type: ignore[attr-defined]
+        new_cls._base_fork = cls._base_fork or cls  # type: ignore[attr-defined]
         return new_cls