feat(fw|tests): add changes for verkle transition tests. (#507)

* feat(fw|tests): add changes for verkle transition tests.

---------

Co-authored-by: Mario Vega <[email protected]>

Author: spencer-tb

src/ethereum_test_forks/__init__.py

@@ -10,6 +10,7 @@
     Cancun,
     Constantinople,
     ConstantinopleFix,
+    EIP6800Transition,
     Frontier,
     GrayGlacier,
     Homestead,
@@ -19,6 +20,7 @@
     Paris,
     Prague,
     Shanghai,
+    ShanghaiEIP6800,
 )
 from .forks.transition import (
     BerlinToLondonAt5,
@@ -60,6 +62,8 @@
     "MuirGlacier",
     "Shanghai",
     "ShanghaiToCancunAtTime15k",
+    "ShanghaiEIP6800",
+    "EIP6800Transition",
     "Cancun",
     "Prague",
     "get_transition_forks",

src/ethereum_test_forks/base_fork.py

@@ -221,6 +221,22 @@ def pre_allocation_blockchain(cls) -> Mapping:
         """
         pass
 
+    @classmethod
+    @abstractmethod
+    def environment_verkle_conversion_starts(cls) -> bool:
+        """
+        Returns true if the fork starts the verkle conversion process.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def environment_verkle_conversion_completed(cls) -> bool:
+        """
+        Returns true if verkle conversion must have been completed by this fork.
+        """
+        pass
+
     # Engine API information abstract methods
     @classmethod
     @abstractmethod

src/ethereum_test_forks/forks/constants.py

@@ -0,0 +1,62 @@
+"""
+Constant values used by the forks.
+"""
+
+from typing import Dict, Generator, Iterator, Mapping, Tuple
+
+from Crypto.Hash import SHA256
+
+# TODO: Use for large verkle conversion init MPT
+MAX_ACCOUNTS = 1000
+MAX_NONCE = 2**64 - 1
+MAX_BALANCE = 2**256 - 1
+MAX_STORAGE_SLOTS_PER_ACCOUNT = 1000
+MAX_ACCOUNT_CODE_SIZE = 2**14 + 2**13  # EIP-170
+
+
+def seed_generator(seed: int) -> Generator[int, None, None]:
+    """
+    Generate a seed using the SHA256 hash function.
+    """
+    seed = int.from_bytes(
+        bytes=SHA256.new(data=seed.to_bytes(length=256, byteorder="big")).digest(), byteorder="big"
+    )
+    while True:
+        yield seed
+        seed = int.from_bytes(
+            bytes=SHA256.new(data=seed.to_bytes(length=256, byteorder="big")).digest(),
+            byteorder="big",
+        )
+
+
+def storage_generator(
+    seed: Iterator[int], max_slots: int
+) -> Generator[Tuple[int, int], None, None]:
+    """
+    Generate storage slots for an account.
+    """
+    MAX_KEY_VALUE = 2**256 - 1
+    for _ in range(max_slots):
+        yield next(seed) % MAX_KEY_VALUE, next(seed) % MAX_KEY_VALUE
+
+
+def account_generator(
+    seed: Iterator[int], max_accounts: int
+) -> Generator[Tuple[int, Dict[str, str | int | Dict[int, int]]], None, None]:
+    """
+    Generate accounts.
+    """
+    for _ in range(max_accounts):
+        storage_g = storage_generator(seed, next(seed) % MAX_STORAGE_SLOTS_PER_ACCOUNT)
+        yield next(seed) % 2**160, {
+            "nonce": next(seed) % MAX_NONCE,
+            "balance": next(seed) % MAX_BALANCE,
+            "storage": {k: v for k, v in storage_g},
+            "code": "0x" + "00" * 32,
+        }
+
+
+VERKLE_PRE_ALLOCATION: Mapping = {
+    addr: account
+    for addr, account in account_generator(seed=seed_generator(0), max_accounts=MAX_ACCOUNTS)
+}

src/ethereum_test_forks/forks/forks.py

@@ -10,6 +10,7 @@
 from semver import Version
 
 from ..base_fork import BaseFork
+from ..transition_base_fork import transition_fork
 
 CURRENT_FILE = Path(realpath(__file__))
 CURRENT_FOLDER = CURRENT_FILE.parent
@@ -188,6 +189,20 @@ def pre_allocation_blockchain(cls) -> Mapping:
         """
         return {}
 
+    @classmethod
+    def environment_verkle_conversion_starts(cls) -> bool:
+        """
+        Returns true if the fork starts the verkle conversion process.
+        """
+        return False
+
+    @classmethod
+    def environment_verkle_conversion_completed(cls) -> bool:
+        """
+        Returns true if verkle conversion must have been completed by this fork.
+        """
+        return False
+
 
 class Homestead(Frontier):
     """
@@ -604,7 +619,65 @@ def engine_forkchoice_updated_version(
         return 3
 
 
-class CancunEIP7692(  # noqa: SC200
+class ShanghaiEIP6800(
+    Shanghai,
+    transition_tool_name="Prague",
+    blockchain_test_network_name="Prague",
+    solc_name="shanghai",
+):
+    """
+    Shanghai + EIP-6800 (Verkle) fork
+    """
+
+    @classmethod
+    def is_deployed(cls) -> bool:
+        """
+        Flags that the fork has not been deployed to mainnet; it is under active
+        development.
+        """
+        return False
+
+    @classmethod
+    def environment_verkle_conversion_completed(cls) -> bool:
+        """
+        Verkle conversion has already completed in this fork.
+        """
+        return True
+
+    @classmethod
+    def pre_allocation_blockchain(cls) -> Mapping:
+        """
+        Verkle requires pre-allocation of the history storage contract for EIP-2935 on blockchain
+        type tests.
+        """
+        new_allocation = {
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE: {
+                "nonce": 1,
+                "code": (
+                    "0x60203611603157600143035f35116029575f35612000014311602957612000"
+                    "5f3506545f5260205ff35b5f5f5260205ff35b5f5ffd00"
+                ),
+            }
+        }
+        # TODO: Utilize when testing for large init MPT
+        # return VERKLE_PRE_ALLOCATION | super(Shanghai, cls).pre_allocation()
+        return new_allocation | super(Shanghai, cls).pre_allocation_blockchain()
+
+
+# TODO: move back to transition.py after filling and executing ShanghaiEIP6800 tests successfully
+@transition_fork(to_fork=ShanghaiEIP6800, at_timestamp=32)
+class EIP6800Transition(
+    Shanghai,
+    blockchain_test_network_name="ShanghaiToPragueAtTime32",
+):
+    """
+    Shanghai to Verkle transition at Timestamp 32.
+    """
+
+    pass
+
+
+class CancunEIP7692(
     Cancun,
     transition_tool_name="Prague",  # Evmone enables (only) EOF at Prague
     blockchain_test_network_name="Prague",  # Evmone enables (only) EOF at Prague

src/ethereum_test_forks/forks/transition.py

@@ -1,11 +1,11 @@
 """
 List of all transition fork definitions.
 """
+
 from ..transition_base_fork import transition_fork
 from .forks import Berlin, Cancun, London, Paris, Prague, Shanghai
 
 
-# Transition Forks
 @transition_fork(to_fork=London, at_block=5)
 class BerlinToLondonAt5(Berlin):
     """

src/ethereum_test_forks/helpers.py

@@ -1,6 +1,7 @@
 """
 Helper methods to resolve forks during test filling
 """
+
 from typing import List, Optional
 
 from semver import Version
@@ -32,6 +33,9 @@ def get_forks() -> List[Fork]:
             continue
         if issubclass(fork, BaseFork) and fork is not BaseFork:
             all_forks.append(fork)
+
+    all_forks += get_transition_forks(always_execute=True)
+
     return all_forks
 
 
@@ -87,7 +91,7 @@ def get_closest_fork_with_solc_support(fork: Fork, solc_version: Version) -> Opt
     )
 
 
-def get_transition_forks() -> List[Fork]:
+def get_transition_forks(always_execute: bool = False) -> List[Fork]:
     """
     Returns all the transition forks
     """
@@ -98,6 +102,8 @@ def get_transition_forks() -> List[Fork]:
         if not isinstance(fork, type):
             continue
         if issubclass(fork, TransitionBaseClass) and issubclass(fork, BaseFork):
+            if always_execute and not fork.always_execute():
+                continue
             transition_forks.append(fork)
 
     return transition_forks

src/ethereum_test_forks/transition_base_fork.py

@@ -30,6 +30,14 @@ def transitions_from(cls) -> Fork:
         """
         raise Exception("Not implemented")
 
+    @classmethod
+    def always_execute(cls) -> bool:
+        """
+        Whether the transition fork should be treated as a normal fork and all tests should
+        be filled with it.
+        """
+        raise Exception("Not implemented")
+
 
 def base_fork_abstract_methods() -> List[str]:
     """
@@ -38,7 +46,9 @@ def base_fork_abstract_methods() -> List[str]:
     return list(getattr(BaseFork, "__abstractmethods__"))
 
 
-def transition_fork(to_fork: Fork, at_block: int = 0, at_timestamp: int = 0):
+def transition_fork(
+    to_fork: Fork, at_block: int = 0, at_timestamp: int = 0, always_execute: bool = False
+):
     """
     Decorator to mark a class as a transition fork.
     """
@@ -102,6 +112,7 @@ def transition_method(
 
         NewTransitionClass.transitions_to = lambda: to_fork  # type: ignore
         NewTransitionClass.transitions_from = lambda: from_fork  # type: ignore
+        NewTransitionClass.always_execute = lambda: always_execute  # type: ignore
         NewTransitionClass.fork_at = lambda block_number=0, timestamp=0: (  # type: ignore
             to_fork if block_number >= at_block and timestamp >= at_timestamp else from_fork
         )

src/ethereum_test_tools/__init__.py

@@ -31,6 +31,7 @@
     TestPrivateKey,
     TestPrivateKey2,
     Transaction,
+    VerkleTree,
     Withdrawal,
     WithdrawalRequest,
     add_kzg_version,
@@ -115,6 +116,7 @@
     "TransactionException",
     "Withdrawal",
     "WithdrawalRequest",
+    "VerkleTree",
     "Yul",
     "YulCompiler",
     "add_kzg_version",

src/ethereum_test_tools/common/__init__.py

@@ -46,6 +46,7 @@
     Requests,
     Storage,
     Transaction,
+    VerkleTree,
     Withdrawal,
     WithdrawalRequest,
 )
@@ -78,6 +79,7 @@
     "TestPrivateKey",
     "TestPrivateKey2",
     "Transaction",
+    "VerkleTree",
     "Withdrawal",
     "WithdrawalRequest",
     "ZeroPaddedHexNumber",