ethereum-execution 2.18.0rc6.dev2__py3-none-any.whl

ethereum_spec_tools/evm_tools/loaders/fixture_loader.py

@@ -0,0 +1,190 @@
+"""
+Defines Load class for loading json fixtures for the evm
+tools (t8n, b11r, etc.) as well as the execution specs
+testing framework.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Tuple
+
+from ethereum_rlp import rlp
+from ethereum_types.numeric import U256
+
+from ethereum.crypto.hash import Hash32, keccak256
+from ethereum.exceptions import StateWithEmptyAccount
+from ethereum.utils.hexadecimal import (
+    hex_to_bytes,
+    hex_to_bytes8,
+    hex_to_bytes32,
+    hex_to_hash,
+    hex_to_u64,
+    hex_to_u256,
+    hex_to_uint,
+)
+
+from .fork_loader import ForkLoad
+from .transaction_loader import TransactionLoad
+
+
+class BaseLoad(ABC):
+    """Base class for loading JSON fixtures."""
+
+    @abstractmethod
+    def json_to_header(self, json_data: Any) -> Any:
+        """Converts json header data to a header object."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def json_to_state(self, json_data: Any) -> Any:
+        """Converts json state data to a state object."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def json_to_block(self, json_data: Any) -> Any:
+        """Converts json block data to a list of blocks."""
+        raise NotImplementedError()
+
+
+class Load(BaseLoad):
+    """Class for loading json fixtures."""
+
+    _network: str
+    _fork_module: str
+    fork: ForkLoad
+
+    def __init__(self, network: str, fork_module: str):
+        self._network = network
+        self._fork_module = fork_module
+        self.fork = ForkLoad(fork_module)
+
+    def json_to_state(self, raw: Any) -> Any:
+        """Converts json state data to a state object."""
+        state = self.fork.State()
+        set_storage = self.fork.set_storage
+        EMPTY_ACCOUNT = self.fork.EMPTY_ACCOUNT  # noqa N806
+
+        for address_hex, account_state in raw.items():
+            address = self.fork.hex_to_address(address_hex)
+            account = self.fork.Account(
+                nonce=hex_to_uint(account_state.get("nonce", "0x0")),
+                balance=U256(hex_to_uint(account_state.get("balance", "0x0"))),
+                code=hex_to_bytes(account_state.get("code", "")),
+            )
+            if self.fork.proof_of_stake and account == EMPTY_ACCOUNT:
+                raise StateWithEmptyAccount(f"Empty account at {address_hex}.")
+
+            self.fork.set_account(state, address, account)
+
+            for k, v in account_state.get("storage", {}).items():
+                set_storage(
+                    state,
+                    address,
+                    hex_to_bytes32(k),
+                    U256.from_be_bytes(hex_to_bytes32(v)),
+                )
+        return state
+
+    def json_to_withdrawals(self, raw: Any) -> Any:
+        """Converts json withdrawal data to a withdrawal object."""
+        parameters = [
+            hex_to_u64(raw.get("index")),
+            hex_to_u64(raw.get("validatorIndex")),
+            self.fork.hex_to_address(raw.get("address")),
+            hex_to_u256(raw.get("amount")),
+        ]
+
+        return self.fork.Withdrawal(*parameters)
+
+    def json_to_block(
+        self,
+        json_block: Any,
+    ) -> Tuple[Any, Hash32, bytes]:
+        """Converts json block data to a block object."""
+        if "rlp" in json_block:
+            # Always decode from rlp
+            block_rlp = hex_to_bytes(json_block["rlp"])
+            block = rlp.decode_to(self.fork.Block, block_rlp)
+            block_header_hash = keccak256(rlp.encode(block.header))
+            return block, block_header_hash, block_rlp
+
+        header = self.json_to_header(json_block["blockHeader"])
+        transactions = tuple(
+            TransactionLoad(tx, self.fork).read()
+            for tx in json_block["transactions"]
+        )
+        uncles = tuple(
+            self.json_to_header(uncle) for uncle in json_block["uncleHeaders"]
+        )
+
+        parameters = [
+            header,
+            transactions,
+            uncles,
+        ]
+
+        if "withdrawals" in json_block:
+            withdrawals = tuple(
+                self.json_to_withdrawals(wd)
+                for wd in json_block["withdrawals"]
+            )
+            parameters.append(withdrawals)
+
+        block = self.fork.Block(*parameters)
+        block_header_hash = Hash32(
+            hex_to_bytes(json_block["blockHeader"]["hash"])
+        )
+        block_rlp = hex_to_bytes(json_block["rlp"])
+
+        return block, block_header_hash, block_rlp
+
+    def json_to_header(self, raw: Any) -> Any:
+        """Converts json header data to a header object."""
+        parameters = [
+            hex_to_hash(raw.get("parentHash")),
+            hex_to_hash(raw.get("uncleHash") or raw.get("sha3Uncles")),
+            self.fork.hex_to_address(raw.get("coinbase") or raw.get("miner")),
+            self.fork.hex_to_root(raw.get("stateRoot")),
+            self.fork.hex_to_root(
+                raw.get("transactionsTrie") or raw.get("transactionsRoot")
+            ),
+            self.fork.hex_to_root(
+                raw.get("receiptTrie") or raw.get("receiptsRoot")
+            ),
+            self.fork.Bloom(
+                hex_to_bytes(raw.get("bloom") or raw.get("logsBloom"))
+            ),
+            hex_to_uint(raw.get("difficulty")),
+            hex_to_uint(raw.get("number")),
+            hex_to_uint(raw.get("gasLimit")),
+            hex_to_uint(raw.get("gasUsed")),
+            hex_to_u256(raw.get("timestamp")),
+            hex_to_bytes(raw.get("extraData")),
+            hex_to_bytes32(raw.get("mixHash")),
+            hex_to_bytes8(raw.get("nonce")),
+        ]
+
+        if "baseFeePerGas" in raw:
+            base_fee_per_gas = hex_to_uint(raw.get("baseFeePerGas"))
+            parameters.append(base_fee_per_gas)
+
+        if "withdrawalsRoot" in raw:
+            withdrawals_root = self.fork.hex_to_root(
+                raw.get("withdrawalsRoot")
+            )
+            parameters.append(withdrawals_root)
+
+        if "excessBlobGas" in raw:
+            blob_gas_used = hex_to_u64(raw.get("blobGasUsed"))
+            parameters.append(blob_gas_used)
+            excess_blob_gas = hex_to_u64(raw.get("excessBlobGas"))
+            parameters.append(excess_blob_gas)
+            parent_beacon_block_root = self.fork.hex_to_root(
+                raw.get("parentBeaconBlockRoot")
+            )
+            parameters.append(parent_beacon_block_root)
+
+        if "requestsHash" in raw:
+            requests_hash = hex_to_bytes32(raw.get("requestsHash"))
+            parameters.append(requests_hash)
+
+        return self.fork.Header(*parameters)

ethereum_spec_tools/evm_tools/loaders/fork_loader.py

@@ -0,0 +1,320 @@
+"""
+Loader for code from the relevant fork.
+"""
+
+import importlib
+from typing import Any
+
+from ethereum_spec_tools.forks import Hardfork
+
+
+class ForkLoad:
+    """
+    Load the functions and classes from the relevant fork.
+    """
+
+    _fork_module: str
+    _forks: list[Hardfork]
+
+    def __init__(self, fork_module: str):
+        self._fork_module = fork_module
+        self._forks = Hardfork.discover()
+
+    @property
+    def fork_module(self) -> str:
+        """Module that contains the fork code."""
+        return self._fork_module
+
+    def _module(self, name: str) -> Any:
+        """Imports a module from the fork."""
+        return importlib.import_module(
+            f"ethereum.forks.{self._fork_module}.{name}"
+        )
+
+    @property
+    def proof_of_stake(self) -> bool:
+        """Whether the fork is proof of stake."""
+        for fork in self._forks:
+            if fork.name == "ethereum.forks." + self._fork_module:
+                return fork.consensus.is_pos()
+        raise Exception(f"fork {self._fork_module} not discovered")
+
+    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.
+        """
+        return_value = False
+        for fork in self._forks:
+            short_name = fork.short_name
+            if short_name == target_fork_name:
+                return_value = True
+            if short_name == self._fork_module:
+                break
+        return return_value
+
+    @property
+    def BEACON_ROOTS_ADDRESS(self) -> Any:
+        """BEACON_ROOTS_ADDRESS of the given fork."""
+        return self._module("fork").BEACON_ROOTS_ADDRESS
+
+    @property
+    def HISTORY_STORAGE_ADDRESS(self) -> Any:
+        """HISTORY_STORAGE_ADDRESS of the given fork."""
+        return self._module("fork").HISTORY_STORAGE_ADDRESS
+
+    @property
+    def BLOCK_REWARD(self) -> Any:
+        """BLOCK_REWARD of the given fork."""
+        return self._module("fork").BLOCK_REWARD
+
+    @property
+    def process_general_purpose_requests(self) -> Any:
+        """process_general_purpose_requests function of the given fork."""
+        return self._module("fork").process_general_purpose_requests
+
+    @property
+    def process_unchecked_system_transaction(self) -> Any:
+        """process_unchecked_system_transaction function of the given fork."""
+        return self._module("fork").process_unchecked_system_transaction
+
+    @property
+    def process_withdrawals(self) -> Any:
+        """process_withdrawals function of the given fork."""
+        return self._module("fork").process_withdrawals
+
+    @property
+    def calculate_block_difficulty(self) -> Any:
+        """calculate_block_difficulty function of the given fork."""
+        return self._module("fork").calculate_block_difficulty
+
+    @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 logs_bloom(self) -> Any:
+        """logs_bloom function of the given fork."""
+        return self._module("bloom").logs_bloom
+
+    @property
+    def BlockChain(self) -> Any:
+        """Block chain class of the fork."""
+        return self._module("fork").BlockChain
+
+    @property
+    def state_transition(self) -> Any:
+        """state_transition function of the fork."""
+        return self._module("fork").state_transition
+
+    @property
+    def signing_hash(self) -> Any:
+        """signing_hash function of the fork."""
+        return self._module("transactions").signing_hash
+
+    @property
+    def signing_hash_pre155(self) -> Any:
+        """signing_hash_pre155 function of the fork."""
+        return self._module("transactions").signing_hash_pre155
+
+    @property
+    def signing_hash_155(self) -> Any:
+        """signing_hash_155 function of the fork."""
+        return self._module("transactions").signing_hash_155
+
+    @property
+    def signing_hash_2930(self) -> Any:
+        """signing_hash_2930 function of the fork."""
+        return self._module("transactions").signing_hash_2930
+
+    @property
+    def signing_hash_1559(self) -> Any:
+        """signing_hash_1559 function of the fork."""
+        return self._module("transactions").signing_hash_1559
+
+    @property
+    def signing_hash_7702(self) -> Any:
+        """signing_hash_7702 function of the fork."""
+        return self._module("transactions").signing_hash_7702
+
+    @property
+    def signing_hash_4844(self) -> Any:
+        """signing_hash_4844 function of the fork."""
+        return self._module("transactions").signing_hash_4844
+
+    @property
+    def get_transaction_hash(self) -> Any:
+        """get_transaction_hash function of the fork."""
+        return self._module("transactions").get_transaction_hash
+
+    @property
+    def process_transaction(self) -> Any:
+        """process_transaction function of the fork."""
+        return self._module("fork").process_transaction
+
+    @property
+    def Block(self) -> Any:
+        """Block class of the fork."""
+        return self._module("blocks").Block
+
+    @property
+    def decode_receipt(self) -> Any:
+        """decode_receipt function of the fork."""
+        return self._module("blocks").decode_receipt
+
+    @property
+    def compute_requests_hash(self) -> Any:
+        """compute_requests_hash function of the fork."""
+        return self._module("requests").compute_requests_hash
+
+    @property
+    def Bloom(self) -> Any:
+        """Bloom class of the fork."""
+        return self._module("fork_types").Bloom
+
+    @property
+    def EMPTY_ACCOUNT(self) -> Any:
+        """EMPTY_ACCOUNT of the fork."""
+        return self._module("fork_types").EMPTY_ACCOUNT
+
+    @property
+    def Header(self) -> Any:
+        """Header class of the fork."""
+        return self._module("blocks").Header
+
+    @property
+    def Account(self) -> Any:
+        """Account class of the fork."""
+        return self._module("fork_types").Account
+
+    @property
+    def Transaction(self) -> Any:
+        """Transaction class of the fork."""
+        return self._module("transactions").Transaction
+
+    @property
+    def LegacyTransaction(self) -> Any:
+        """Legacytransaction class of the fork."""
+        return self._module("transactions").LegacyTransaction
+
+    @property
+    def Access(self) -> Any:
+        """Access class of the fork."""
+        return self._module("transactions").Access
+
+    @property
+    def AccessListTransaction(self) -> Any:
+        """Access List transaction class of the fork."""
+        return self._module("transactions").AccessListTransaction
+
+    @property
+    def FeeMarketTransaction(self) -> Any:
+        """Fee Market transaction class of the fork."""
+        return self._module("transactions").FeeMarketTransaction
+
+    @property
+    def BlobTransaction(self) -> Any:
+        """Blob transaction class of the fork."""
+        return self._module("transactions").BlobTransaction
+
+    @property
+    def SetCodeTransaction(self) -> Any:
+        """Set code transaction class of the fork."""
+        return self._module("transactions").SetCodeTransaction
+
+    @property
+    def Withdrawal(self) -> Any:
+        """Withdrawal class of the fork."""
+        return self._module("blocks").Withdrawal
+
+    @property
+    def decode_transaction(self) -> Any:
+        """decode_transaction function of the fork."""
+        return self._module("transactions").decode_transaction
+
+    @property
+    def State(self) -> Any:
+        """State class of the fork."""
+        return self._module("state").State
+
+    @property
+    def set_account(self) -> Any:
+        """set_account function of the fork."""
+        return self._module("state").set_account
+
+    @property
+    def set_storage(self) -> Any:
+        """set_storage function of the fork."""
+        return self._module("state").set_storage
+
+    @property
+    def state_root(self) -> Any:
+        """state_root function of the fork."""
+        return self._module("state").state_root
+
+    @property
+    def close_state(self) -> Any:
+        """close_state function of the fork."""
+        return self._module("state").close_state
+
+    @property
+    def create_ether(self) -> Any:
+        """create_ether function of the fork."""
+        return self._module("state").create_ether
+
+    @property
+    def root(self) -> Any:
+        """Root function of the fork."""
+        return self._module("trie").root
+
+    @property
+    def copy_trie(self) -> Any:
+        """copy_trie function of the fork."""
+        return self._module("trie").copy_trie
+
+    @property
+    def trie_get(self) -> Any:
+        """trie_get function of the fork."""
+        return self._module("trie").trie_get
+
+    @property
+    def hex_to_address(self) -> Any:
+        """hex_to_address function of the fork."""
+        return self._module("utils.hexadecimal").hex_to_address
+
+    @property
+    def hex_to_root(self) -> Any:
+        """hex_to_root function of the fork."""
+        return self._module("utils.hexadecimal").hex_to_root
+
+    @property
+    def BlockEnvironment(self) -> Any:
+        """Block environment class of the fork."""
+        return self._module("vm").BlockEnvironment
+
+    @property
+    def BlockOutput(self) -> Any:
+        """Block output class of the fork."""
+        return self._module("vm").BlockOutput
+
+    @property
+    def Authorization(self) -> Any:
+        """Authorization class of the fork."""
+        return self._module("fork_types").Authorization
+
+    @property
+    def calculate_excess_blob_gas(self) -> Any:
+        """calculate_excess_blob_gas of the fork."""
+        return self._module("vm.gas").calculate_excess_blob_gas
+
+    @property
+    def calculate_blob_gas_price(self) -> Any:
+        """calculate_blob_gas_price of the fork."""
+        return self._module("vm.gas").calculate_blob_gas_price
+
+    @property
+    def apply_dao(self) -> Any:
+        """apply_dao function of the fork."""
+        return self._module("dao").apply_dao