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

ethereum_spec_tools/evm_tools/loaders/transaction_loader.py

@@ -0,0 +1,208 @@
+"""
+Read transaction data from json file and return the
+relevant transaction.
+"""
+
+from dataclasses import fields
+from typing import Any, List
+
+from ethereum_rlp import rlp
+from ethereum_types.bytes import Bytes, Bytes0, Bytes32
+from ethereum_types.numeric import U64, U256, Uint
+
+from ethereum.utils.hexadecimal import (
+    hex_to_bytes,
+    hex_to_bytes32,
+    hex_to_hash,
+    hex_to_u8,
+    hex_to_u64,
+    hex_to_u256,
+    hex_to_uint,
+)
+from ethereum_spec_tools.evm_tools.utils import parse_hex_or_int
+
+
+class UnsupportedTxError(Exception):
+    """Exception for unsupported transactions."""
+
+    def __init__(self, encoded_params: bytes, error_message: str) -> None:
+        super().__init__(error_message)
+        self.encoded_params = encoded_params
+        self.error_message = error_message
+
+
+class TransactionLoad:
+    """
+    Class for loading transaction data from json file.
+    """
+
+    def __init__(self, raw: Any, fork: Any) -> None:
+        self.raw = raw
+        self.fork = fork
+
+    def json_to_chain_id(self) -> U64:
+        """Get chain ID for the transaction."""
+        return U64(1)
+
+    def json_to_nonce(self) -> U256:
+        """Get the nonce for the transaction."""
+        return hex_to_u256(self.raw.get("nonce"))
+
+    def json_to_gas_price(self) -> Uint:
+        """Get the gas price for the transaction."""
+        return hex_to_uint(self.raw.get("gasPrice"))
+
+    def json_to_gas(self) -> Uint:
+        """Get the gas limit for the transaction."""
+        return hex_to_uint(self.raw.get("gasLimit"))
+
+    def json_to_to(self) -> Bytes:
+        """Get to address for the transaction."""
+        if self.raw.get("to") == "":
+            return Bytes0(b"")
+        return self.fork.hex_to_address(self.raw.get("to"))
+
+    def json_to_value(self) -> U256:
+        """Get the value of the transaction."""
+        value = self.raw.get("value")
+        if value == "0x":
+            return U256(0)
+        return hex_to_u256(value)
+
+    def json_to_data(self) -> Bytes:
+        """Get the data of the transaction."""
+        return hex_to_bytes(self.raw.get("data"))
+
+    def json_to_access_list(self) -> Any:
+        """Get the access list of the transaction."""
+        access_list = []
+        for sublist in self.raw.get("accessList", []):
+            access_list.append(
+                self.fork.Access(
+                    self.fork.hex_to_address(sublist.get("address")),
+                    [
+                        hex_to_bytes32(key)
+                        for key in sublist.get("storageKeys")
+                    ],
+                )
+            )
+        return access_list
+
+    def json_to_authorizations(self) -> Any:
+        """Get the authorization list of the transaction."""
+        authorizations = []
+        for sublist in self.raw["authorizationList"]:
+            authorizations.append(
+                self.fork.Authorization(
+                    chain_id=hex_to_u256(sublist.get("chainId")),
+                    nonce=hex_to_u64(sublist.get("nonce")),
+                    address=self.fork.hex_to_address(sublist.get("address")),
+                    y_parity=hex_to_u8(sublist.get("v")),
+                    r=hex_to_u256(sublist.get("r")),
+                    s=hex_to_u256(sublist.get("s")),
+                )
+            )
+        return authorizations
+
+    def json_to_max_priority_fee_per_gas(self) -> Uint:
+        """Get the max priority fee per gas of the transaction."""
+        return hex_to_uint(self.raw.get("maxPriorityFeePerGas"))
+
+    def json_to_max_fee_per_gas(self) -> Uint:
+        """Get the max fee per gas of the transaction."""
+        return hex_to_uint(self.raw.get("maxFeePerGas"))
+
+    def json_to_max_fee_per_blob_gas(self) -> U256:
+        """
+        Get the max priority fee per blobgas of the transaction.
+        """
+        return hex_to_u256(self.raw.get("maxFeePerBlobGas"))
+
+    def json_to_blob_versioned_hashes(self) -> List[Bytes32]:
+        """Get the blob versioned hashes of the transaction."""
+        return [
+            hex_to_hash(blob_hash)
+            for blob_hash in self.raw.get("blobVersionedHashes")
+        ]
+
+    def json_to_v(self) -> U256:
+        """Get the v value of the transaction."""
+        return hex_to_u256(
+            self.raw.get("y_parity")
+            if "y_parity" in self.raw
+            else self.raw.get("v")
+        )
+
+    def json_to_y_parity(self) -> U256:
+        """Get the y parity of the transaction."""
+        return self.json_to_v()
+
+    def json_to_r(self) -> U256:
+        """Get the r value of the transaction."""
+        return hex_to_u256(self.raw.get("r"))
+
+    def json_to_s(self) -> U256:
+        """Get the s value of the transaction."""
+        return hex_to_u256(self.raw.get("s"))
+
+    def get_parameters(self, tx_cls: Any) -> List:
+        """
+        Extract all the transaction parameters from the json file.
+        """
+        parameters = []
+        for field in fields(tx_cls):
+            parameters.append(getattr(self, f"json_to_{field.name}")())
+        return parameters
+
+    def get_legacy_transaction(self) -> Any:
+        """Return the appropriate class for legacy transactions."""
+        if hasattr(self.fork, "LegacyTransaction"):
+            return self.fork.LegacyTransaction
+        else:
+            return self.fork.Transaction
+
+    def read(self) -> Any:
+        """Convert json transaction data to a transaction object."""
+        if "type" in self.raw:
+            tx_type = parse_hex_or_int(self.raw.get("type"), Uint)
+            if tx_type == Uint(4):
+                tx_cls = self.fork.SetCodeTransaction
+                tx_byte_prefix = b"\x04"
+            elif tx_type == Uint(3):
+                tx_cls = self.fork.BlobTransaction
+                tx_byte_prefix = b"\x03"
+            elif tx_type == Uint(2):
+                tx_cls = self.fork.FeeMarketTransaction
+                tx_byte_prefix = b"\x02"
+            elif tx_type == Uint(1):
+                tx_cls = self.fork.AccessListTransaction
+                tx_byte_prefix = b"\x01"
+            elif tx_type == Uint(0):
+                tx_cls = self.get_legacy_transaction()
+                tx_byte_prefix = b""
+            else:
+                raise ValueError(f"Unknown transaction type: {tx_type}")
+        else:
+            if "authorizationList" in self.raw:
+                tx_cls = self.fork.SetCodeTransaction
+                tx_byte_prefix = b"\x04"
+            elif "maxFeePerBlobGas" in self.raw:
+                tx_cls = self.fork.BlobTransaction
+                tx_byte_prefix = b"\x03"
+            elif "maxFeePerGas" in self.raw:
+                tx_cls = self.fork.FeeMarketTransaction
+                tx_byte_prefix = b"\x02"
+            elif "accessList" in self.raw:
+                tx_cls = self.fork.AccessListTransaction
+                tx_byte_prefix = b"\x01"
+            else:
+                tx_cls = self.get_legacy_transaction()
+                tx_byte_prefix = b""
+
+        parameters = self.get_parameters(tx_cls)
+        try:
+            return tx_cls(*parameters)
+        except Exception as e:
+            raise UnsupportedTxError(
+                tx_byte_prefix + rlp.encode(parameters), str(e)
+            ) from e

ethereum_spec_tools/evm_tools/statetest/__init__.py

@@ -0,0 +1,291 @@
+"""
+Execute state tests.
+"""
+
+import argparse
+import json
+import logging
+import sys
+from copy import deepcopy
+from dataclasses import dataclass
+from io import StringIO
+from typing import Any, Dict, Iterable, List, Optional, TextIO
+
+from ethereum.utils.hexadecimal import hex_to_bytes
+
+from ..t8n import T8N
+from ..t8n.t8n_types import Result
+from ..utils import get_supported_forks
+
+
+@dataclass
+class TestCase:
+    """
+    A test case derived from the inputs common to all forks and a single
+    post-state unique to a single fork.
+    """
+
+    path: str
+    key: str
+    index: int
+    fork_name: str
+    post: Dict
+    pre: Dict
+    env: Dict
+    transaction: Dict
+
+
+def read_test_cases(test_file_path: str) -> Iterable[TestCase]:
+    """
+    Given a path to a filled state test in JSON format, return all the
+    `TestCase`s it contains.
+    """
+    with open(test_file_path) as test_file:
+        tests = json.load(test_file)
+
+    for key, test in tests.items():
+        env = test["env"]
+        if not isinstance(env, dict):
+            raise TypeError("env not dict")
+
+        pre = test["pre"]
+        if not isinstance(pre, dict):
+            raise TypeError("pre not dict")
+
+        transaction = test["transaction"]
+        if not isinstance(transaction, dict):
+            raise TypeError("transaction not dict")
+
+        for fork_name, content in test["post"].items():
+            for idx, post in enumerate(content):
+                if not isinstance(post, dict):
+                    raise TypeError(f'post["{fork_name}"] not dict')
+
+                yield TestCase(
+                    path=test_file_path,
+                    key=key,
+                    index=idx,
+                    fork_name=fork_name,
+                    post=post,
+                    env=env,
+                    pre=pre,
+                    transaction=transaction,
+                )
+
+
+def run_test_case(
+    test_case: TestCase,
+    t8n_extra: Optional[List[str]] = None,
+    output_basedir: Optional[str | TextIO] = None,
+) -> Result:
+    """
+    Runs a single general state test.
+    """
+    from .. import create_parser
+
+    env = deepcopy(test_case.env)
+    try:
+        env["blockHashes"] = {"0": env["previousHash"]}
+    except KeyError:
+        env["blockHashes"] = {}
+    env["withdrawals"] = []
+
+    alloc = deepcopy(test_case.pre)
+
+    post = deepcopy(test_case.post)
+    d = post["indexes"]["data"]
+    g = post["indexes"]["gas"]
+    v = post["indexes"]["value"]
+
+    tx = {}
+    for k, value in test_case.transaction.items():
+        if k == "data":
+            tx["input"] = value[d]
+        elif k == "gasLimit":
+            tx["gas"] = value[g]
+        elif k == "value":
+            tx[k] = value[v]
+        elif k == "accessLists":
+            if value[d] is not None:
+                tx["accessList"] = value[d]
+        else:
+            tx[k] = value
+
+    txs = [tx]
+
+    in_stream = StringIO(
+        json.dumps(
+            {
+                "env": env,
+                "alloc": alloc,
+                "txs": txs,
+            }
+        )
+    )
+    out_stream = StringIO()
+
+    # Run the t8n tool
+    t8n_args = [
+        "t8n",
+        "--input.alloc",
+        "stdin",
+        "--input.env",
+        "stdin",
+        "--input.txs",
+        "stdin",
+        "--state.fork",
+        f"{test_case.fork_name}",
+        "--state-test",
+    ]
+
+    if t8n_extra is not None:
+        t8n_args.extend(t8n_extra)
+
+    parser = create_parser()
+    t8n_options = parser.parse_args(t8n_args)
+    if output_basedir is not None:
+        t8n_options.output_basedir = output_basedir
+
+    t8n = T8N(t8n_options, out_stream, in_stream)
+    t8n.run_state_test()
+    return t8n.result
+
+
+def state_test_arguments(subparsers: argparse._SubParsersAction) -> None:
+    """
+    Adds the arguments for the statetest tool subparser.
+    """
+    statetest_parser = subparsers.add_parser(
+        "statetest",
+        help="Runs state tests from a file or from the standard input.",
+    )
+
+    statetest_parser.add_argument("file", nargs="?", default=None)
+    statetest_parser.add_argument("--json", action="store_true", default=False)
+    statetest_parser.add_argument(
+        "--noreturndata",
+        dest="return_data",
+        action="store_false",
+        default=True,
+    )
+    statetest_parser.add_argument(
+        "--nostack", dest="stack", action="store_false", default=True
+    )
+    statetest_parser.add_argument(
+        "--nomemory", dest="memory", action="store_false", default=True
+    )
+
+
+class _PrefixFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        output = super().format(record)
+        return "\n".join("# " + x for x in output.splitlines())
+
+
+class StateTest:
+    """
+    Run one or more state tests.
+    """
+
+    def __init__(
+        self, options: Any, out_file: TextIO, in_file: TextIO
+    ) -> None:
+        self.file = options.file
+        self.out_file = out_file
+        self.in_file = in_file
+        self.supported_forks = tuple(
+            x.casefold() for x in get_supported_forks()
+        )
+        self.trace: bool = options.json
+        self.memory: bool = options.memory
+        self.stack: bool = options.stack
+        self.return_data: bool = options.return_data
+
+    def run(self) -> int:
+        """
+        Execute the tests.
+        """
+        logger = logging.getLogger("T8N")
+        logger.setLevel(level=logging.INFO)
+        stream_handler = logging.StreamHandler()
+        formatter = _PrefixFormatter("%(levelname)s:%(name)s:%(message)s")
+        stream_handler.setFormatter(formatter)
+        logger.addHandler(stream_handler)
+
+        if self.file is None:
+            return self.run_many()
+        else:
+            return self.run_one(self.file)
+
+    def run_one(self, path: str) -> int:
+        """
+        Execute state tests from a single file.
+        """
+        results = []
+        for test_case in read_test_cases(path):
+            if test_case.fork_name.casefold() not in self.supported_forks:
+                continue
+
+            t8n_extra: List[str] = []
+
+            if self.trace:
+                t8n_extra.append("--trace")
+
+            if self.memory:
+                t8n_extra.append("--trace.memory")
+            else:
+                t8n_extra.append("--trace.nomemory")
+
+            if not self.stack:
+                t8n_extra.append("--trace.nostack")
+
+            if self.return_data:
+                t8n_extra.append("--trace.returndata")
+            else:
+                t8n_extra.append("--trace.noreturndata")
+
+            result = run_test_case(
+                test_case,
+                t8n_extra=t8n_extra,
+                output_basedir=sys.stderr,
+            )
+
+            # Always output the state root on stderr (even with tracing
+            # disabled) for the holiman/goevmlab integration.
+            json.dump(
+                {"stateRoot": "0x" + result.state_root.hex()},
+                sys.stderr,
+            )
+            sys.stderr.write("\n")
+
+            passed = hex_to_bytes(test_case.post["hash"]) == result.state_root
+            result_dict = {
+                "stateRoot": "0x" + result.state_root.hex(),
+                "fork": test_case.fork_name,
+                "name": test_case.key,
+                "pass": passed,
+            }
+
+            if not passed:
+                actual = result.state_root.hex()
+                expected = test_case.post["hash"][2:]
+                result_dict["error"] = (
+                    f"post state root mismatch: got {actual}, want {expected}"
+                )
+
+            results.append(result_dict)
+
+        json.dump(results, self.out_file, indent=4)
+        self.out_file.write("\n")
+        return 0
+
+    def run_many(self) -> int:
+        """
+        Execute state tests from a line-delimited list of files provided from
+        `self.in_file`.
+        """
+        for line in self.in_file:
+            result = self.run_one(line[:-1])
+            if result != 0:
+                return result
+        return 0