pdobacz · Oct 20, 2026 · Jun 25, 2026 · Jun 25, 2026 · Jun 25, 2026 · Jul 27, 2026
@@ -1,11 +1,11 @@
 monad:
   evm-type: eels
-  fill-params: -m blockchain_test --from=MONAD_EIGHT --until=MONAD_TEN --chain-id=143 -k "not invalid_header"
+  fill-params: -m blockchain_test --from=MONAD_EIGHT --until=MONAD_ELEVEN --chain-id=143 -k "not invalid_header"
 
 monad_runloop:
   evm-type: eels
   # Like `monad`, but `--monad-runloop` and eestnet chain id `30143`
-  fill-params: -m blockchain_test --from=MONAD_EIGHT --until=MONAD_TEN --chain-id=30143 --monad-runloop -k "not invalid_header"
+  fill-params: -m blockchain_test --from=MONAD_EIGHT --until=MONAD_ELEVEN --chain-id=30143 --monad-runloop -k "not invalid_header"
 
 monad_benchmark:
   evm-type: eels

@@ -75,7 +75,7 @@
     "MONAD_EIGHT",
     "MONAD_NINE",
     "MONAD_TEN",
-    "MONAD_NEXT",
+    "MONAD_ELEVEN",
 ]
 
 FORK_INDEX = {name: i for i, name in enumerate(FORK_ORDER)}

@@ -242,7 +242,7 @@ fn main() {
     }
 
     // The canonical state root is the page-encoded secondary timeline's
-    // from MONAD_NEXT (MIP-8, revision 10) on, the slot-encoded
+    // from MONAD_ELEVEN (MIP-8, revision 10) on, the slot-encoded
     // primary's before. The schedule is ascending, so the last entry is
     // the revision the run ends in.
     let final_revision = input

@@ -182,7 +182,11 @@ def build_genesis_header(
         requests_hash=Requests()
         if genesis_fork.header_requests_required()
         else None,
-        block_access_list_hash=BlockAccessList().rlp_hash
+        block_access_list_hash=(
+            BlockAccessList().rlp_hash
+            if genesis_fork.supports_block_access_lists()
+            else Hash(0)
+        )
         if genesis_fork.header_bal_hash_required()
         else None,
         slot_number=0 if genesis_fork.header_slot_number_required() else None,

@@ -1275,7 +1275,9 @@ def _process_with_marker_args(
                 "Missing fork argument with 'valid_at_transition_to' marker."
             )
 
-        if len(forks) > 1:
+        # A single EIP argument expands to one fork per enabling fork, so
+        # the limit is on the arguments rather than on the resolved forks.
+        if len(fork_args) > 1:
             raise Exception(
                 "Too many forks specified to 'valid_at_transition_to' marker."
             )

@@ -50,10 +50,10 @@
     "MONAD_EIGHT": [(8, 0)],
     "MONAD_NINE": [(9, 0)],
     "MONAD_TEN": [(10, 0)],
-    "MONAD_NEXT": [(11, 0)],
+    "MONAD_ELEVEN": [(11, 0)],
     "MONAD_EIGHTToMONAD_NINEAtTime15k": [(8, 0), (9, 15_000)],
     "MONAD_NINEToMONAD_TENAtTime15k": [(9, 0), (10, 15_000)],
-    "MONAD_TENToMONAD_NEXTAtTime15k": [(10, 0), (11, 15_000)],
+    "MONAD_TENToMONAD_ELEVENAtTime15k": [(10, 0), (11, 15_000)],
 }
 
 

@@ -160,7 +160,7 @@ def _resolve_excess_blob_gas(
     }
     if fork.has_compute_requests_hash:
         arguments["requests_hash"] = Hash32(b"\0" * 32)
-    if fork.has_hash_block_access_list:
+    if fork.has_block_access_list_hash_header:
         arguments["block_access_list_hash"] = Hash32(b"\0" * 32)
     if fork.has_slot_number:
         arguments["slot_number"] = U64(0)

@@ -397,7 +397,13 @@ def genesis(cls, fork: Fork, env: Environment, state_root: Hash) -> Self:
         if fork.header_requests_required():
             extras["requests_hash"] = Requests()
         if fork.header_bal_hash_required():
-            extras["block_access_list_hash"] = BlockAccessList().rlp_hash
+            # A fork can require the header field without building block
+            # access lists (e.g. Monad); the field is then fixed at zero.
+            extras["block_access_list_hash"] = (
+                BlockAccessList().rlp_hash
+                if fork.supports_block_access_lists()
+                else Hash(0)
+            )
         if fork.header_slot_number_required():
             extras["slot_number"] = (
                 int(env.slot_number) if env.slot_number is not None else 0

@@ -18,7 +18,7 @@
     BPO4,
     BPO5,
     MONAD_EIGHT,
-    MONAD_NEXT,
+    MONAD_ELEVEN,
     MONAD_NINE,
     MONAD_TEN,
     Amsterdam,
@@ -52,7 +52,7 @@
     CancunToPragueAtTime15k,
     MONAD_EIGHTToMONAD_NINEAtTime15k,
     MONAD_NINEToMONAD_TENAtTime15k,
-    MONAD_TENToMONAD_NEXTAtTime15k,
+    MONAD_TENToMONAD_ELEVENAtTime15k,
     OsakaToBPO1AtTime15k,
     ParisToShanghaiAtTime15k,
     PragueToOsakaAtTime15k,
@@ -161,8 +161,8 @@
     "MONAD_NINE",
     "MONAD_NINEToMONAD_TENAtTime15k",
     "MONAD_TEN",
-    "MONAD_TENToMONAD_NEXTAtTime15k",
-    "MONAD_NEXT",
+    "MONAD_TENToMONAD_ELEVENAtTime15k",
+    "MONAD_ELEVEN",
     "BPO1",
     "BPO1ToBPO2AtTime15k",
     "BPO2",

@@ -335,12 +335,30 @@ def _maybe_transitioned(fork_cls: "BaseForkMeta") -> "BaseForkMeta":
     @staticmethod
     def _is_subclass_of(a: "BaseForkMeta", b: "BaseForkMeta") -> bool:
         """
-        Check if `a` is a subclass of `b`, taking fork transitions into
-        account.
+        Check if `a` is a subclass of `b`, taking fork transitions and
+        declared succession into account.
+
+        A fork can follow another fork it does not inherit from, which
+        places it after that fork (and after everything that fork comes
+        after) in the fork order without adopting its behavior. The
+        EIPs of a followed fork stay out of that ordering.
         """
         a = BaseForkMeta._maybe_transitioned(a)
         b = BaseForkMeta._maybe_transitioned(b)
-        return issubclass(a, b)
+        if issubclass(a, b):
+            return True
+        # The metaclass sees its instances as plain classes, so the
+        # traits are reached through a cast, as elsewhere in this class.
+        # Succession places a fork after another fork, not after that
+        # fork's EIPs; an adopted EIP is reached by inheritance above.
+        if cast(Type["BaseFork"], b).is_eip():
+            return False
+        followed = cast(Type["BaseFork"], a).follows()
+        while followed is not None:
+            if issubclass(followed, b):
+                return True
+            followed = followed.follows()
+        return False
 
     def __gt__(cls, other: "BaseForkMeta") -> bool:
         """Compare if a fork is newer than some other fork (cls > other)."""
@@ -565,6 +583,17 @@ def header_bal_hash_required(cls) -> bool:
         """Return true if the header must contain block access list hash."""
         pass
 
+    @classmethod
+    def supports_block_access_lists(cls) -> bool:
+        """
+        Return true if the fork builds block access lists (EIP-7928).
+
+        A fork can require the block access list hash header field
+        without building the lists, and then fixes the field at zero, so
+        this follows the EIP rather than the header requirement.
+        """
+        return cls.is_eip_enabled(7928)
+
     @classmethod
     @abstractmethod
     def empty_block_bal_item_count(cls) -> int:
@@ -1469,6 +1498,17 @@ def enabling_forks(cls) -> Set[Type["BaseFork"]]:
             raise Exception(f"Class {cls.__name__} is not an EIP.")
         return cls._enabling_forks
 
+    @classmethod
+    def follows(cls) -> Type["BaseFork"] | None:
+        """
+        Return the fork this one comes after without inheriting it.
+
+        A fork that reuses another lineage's ordering overrides this;
+        comparisons then place it after that fork, and after everything
+        that fork comes after, while its behavior stays its own.
+        """
+        return None
+
     @classmethod
     def parent(cls) -> Type["BaseFork"] | None:
         """Return the parent fork."""

@@ -1838,12 +1838,6 @@ def _calculate_sstore_gas_mip8(
         return gas_cost
 
 
-class MONAD_NEXT(MONAD_TEN):  # noqa: N801
-    """MONAD_NEXT fork, a placeholder identical to MONAD_TEN."""
-
-    pass
-
-
 class BPO1(
     Osaka,
     bpo_fork=True,
@@ -1947,3 +1941,37 @@ class Bogota(
     """Bogota fork."""
 
     pass
+
+
+class MONAD_ELEVEN(  # noqa: N801
+    eips.EIP7708,
+    eips.EIP7843,
+    eips.EIP7981,
+    eips.EIP7997,
+    eips.EIP8024,
+    eips.EIP8246,
+    MONAD_TEN,
+    deployed=False,
+):
+    """
+    MONAD_ELEVEN fork.
+
+    Amsterdam-based successor to MONAD_TEN, adopting the EIP-7708,
+    EIP-7843, EIP-7981, EIP-7997, EIP-8024 and EIP-8246 changes. The
+    Amsterdam changes it does not adopt stay out of the fork by not
+    being inherited at all; the fork order still places MONAD_ELEVEN
+    after Amsterdam through `follows`.
+    """
+
+    @classmethod
+    def follows(cls) -> type[BaseFork] | None:
+        """MONAD_ELEVEN comes after Amsterdam without inheriting it."""
+        return Amsterdam
+
+    @classmethod
+    def header_bal_hash_required(cls) -> bool:
+        """
+        MONAD_ELEVEN headers carry the block access list hash field, fixed
+        at zero, without building block access lists (EIP-7928).
+        """
+        return True
@@ -7,7 +7,7 @@
     BPO3,
     BPO4,
     MONAD_EIGHT,
-    MONAD_NEXT,
+    MONAD_ELEVEN,
     MONAD_NINE,
     MONAD_TEN,
     Amsterdam,
@@ -74,9 +74,11 @@ class MONAD_NINEToMONAD_TENAtTime15k(TransitionBaseClass):  # noqa: N801
     pass
 
 
-@transition_fork(to_fork=MONAD_NEXT, from_fork=MONAD_TEN, at_timestamp=15_000)
-class MONAD_TENToMONAD_NEXTAtTime15k(TransitionBaseClass):  # noqa: N801
-    """MONAD_TEN to MONAD_NEXT transition at Timestamp 15k."""
+@transition_fork(
+    to_fork=MONAD_ELEVEN, from_fork=MONAD_TEN, at_timestamp=15_000
+)
+class MONAD_TENToMONAD_ELEVENAtTime15k(TransitionBaseClass):  # noqa: N801
+    """MONAD_TEN to MONAD_ELEVEN transition at Timestamp 15k."""
 
     pass
 

@@ -10,6 +10,7 @@
 from execution_testing.vm import Opcodes
 
 from ..base_fork import BaseFork, BaseForkMeta, SystemCallPhase
+from ..forks.eips import EIP2780, EIP7708, EIP8024
 from ..forks.eips.paris.eip_3675 import EIP3675
 from ..forks.forks import (
     BPO1,
@@ -18,6 +19,8 @@
     BPO4,
     BPO5,
     MONAD_EIGHT,
+    MONAD_ELEVEN,
+    MONAD_TEN,
     Amsterdam,
     Berlin,
     Bogota,
@@ -304,6 +307,25 @@ def test_fork_comparison() -> None:
     assert fork == Berlin
 
 
+def test_succession_does_not_imply_eip_membership() -> None:
+    """
+    A fork placed after another by `follows` does not gain its EIPs.
+
+    Succession orders MONAD_ELEVEN after Amsterdam so the Amsterdam
+    suites can select it, while the EIPs it declines must still compare
+    as absent. An adopted EIP is reached through inheritance instead, so
+    it keeps comparing as present.
+    """
+    assert MONAD_ELEVEN > Amsterdam
+    assert MONAD_ELEVEN > MONAD_TEN
+
+    assert MONAD_ELEVEN >= EIP7708
+    assert MONAD_ELEVEN.is_eip_enabled(7708)
+
+    assert not MONAD_ELEVEN >= EIP2780
+    assert not MONAD_ELEVEN.is_eip_enabled(2780)
+
+
 def test_transition_fork_comparison() -> None:
     """
     Test comparing to a transition fork.
@@ -390,6 +412,39 @@ class PreAllocTransitionFork(TransitionBaseClass):
     pass
 
 
+def test_monad_eleven_is_not_deployed() -> None:
+    """
+    A fork under development must stay out of the deployed fork range.
+    """
+    deployed_forks = get_deployed_forks()
+    assert MONAD_TEN in deployed_forks
+    assert MONAD_ELEVEN not in deployed_forks
+
+
+def opcode_names(fork: Type[BaseFork]) -> set[str]:
+    """Return the names of the opcodes a fork declares valid."""
+    return {str(opcode) for opcode in fork.valid_opcodes()}
+
+
+def test_adopted_opcodes_depend_on_mixin_order() -> None:
+    """
+        The adopted opcodes reach MONAD_ELEVEN through its mixin order.
+
+    MONAD_NINE returning Osaka's list directly is what ends the chain
+        there, which is what lets a mixin placed ahead of the Monad forks
+        contribute on the way out. Making that call cooperative, or
+        reordering MONAD_ELEVEN's bases, drops these opcodes silently.
+    """
+    adopted = {"DUPN", "SWAPN", "EXCHANGE"}
+    assert adopted <= opcode_names(MONAD_ELEVEN)
+    assert not adopted & opcode_names(MONAD_TEN)
+
+    class MixinAfterFork(MONAD_TEN, EIP8024):  # noqa: N801
+        """Dummy fork ordering an EIP mixin after the Monad fork."""
+
+    assert not adopted & opcode_names(MixinAfterFork)
+
+
 def test_pre_alloc() -> None:  # noqa: D103
     assert PrePreAllocFork.pre_allocation() == {"test": "test"}
     assert PreAllocFork.pre_allocation() == {"test": "test", "test2": "test2"}

@@ -1095,6 +1095,16 @@ def generate_block_data(
                 int(env.slot_number) if env.slot_number is not None else 0
             )
 
+        # Prepare block_access_list_hash for header initialization
+        bal_hash_field: Dict[str, Any] = {}
+        if fork.header_bal_hash_required() and (
+            not fork.supports_block_access_lists()
+        ):
+            # Fork requires the block access list hash header field but
+            # doesn't build block access lists (e.g. Monad): fix value at
+            # zero.
+            bal_hash_field["block_access_list_hash"] = Hash(0)
+
         header = FixtureHeader(
             **(
                 transition_tool_output.result.model_dump(
@@ -1105,6 +1115,7 @@ def generate_block_data(
                     exclude_none=True,
                     exclude={"blob_gas_used", "slot_number"},
                 )
+                | bal_hash_field
             ),
             blob_gas_used=blob_gas_used,
             transactions_trie=Transaction.list_root(txs),
@@ -1168,7 +1179,7 @@ def generate_block_data(
         if t8n_bal_rlp is not None:
             t8n_bal = BlockAccessList.from_rlp(t8n_bal_rlp)
 
-        if fork.header_bal_hash_required():
+        if fork.supports_block_access_lists():
             assert t8n_bal is not None, (
                 "Block access list is required for this block but was not "
                 "provided by the transition tool"