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

ethereum_spec_tools/evm_tools/t8n/env.py

@@ -0,0 +1,320 @@
+"""
+Define t8n Env class.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from ethereum_rlp import rlp
+from ethereum_types.bytes import Bytes8, Bytes20, Bytes32, Bytes256
+from ethereum_types.numeric import U64, U256, Uint
+
+from ethereum.crypto.hash import Hash32, keccak256
+from ethereum.utils.byte import left_pad_zero_bytes
+from ethereum.utils.hexadecimal import hex_to_bytes
+
+from ..utils import parse_hex_or_int
+
+if TYPE_CHECKING:
+    from ethereum_spec_tools.evm_tools.t8n import T8N
+
+
+@dataclass
+class Ommer:
+    """The Ommer type for the t8n tool."""
+
+    delta: str
+    address: Any
+
+
+class Env:
+    """
+    The environment for the transition tool.
+    """
+
+    coinbase: Any
+    block_gas_limit: Uint
+    block_number: Uint
+    block_timestamp: U256
+    parent_hash: Any
+    withdrawals: Any
+    block_difficulty: Optional[Uint]
+    prev_randao: Optional[Bytes32]
+    parent_difficulty: Optional[Uint]
+    parent_timestamp: Optional[U256]
+    base_fee_per_gas: Optional[Uint]
+    parent_gas_used: Optional[Uint]
+    parent_gas_limit: Optional[Uint]
+    parent_base_fee_per_gas: Optional[Uint]
+    block_hashes: Optional[List[Any]]
+    parent_ommers_hash: Optional[Hash32]
+    ommers: Any
+    parent_beacon_block_root: Optional[Hash32]
+    parent_excess_blob_gas: Optional[U64]
+    parent_blob_gas_used: Optional[U64]
+    excess_blob_gas: Optional[U64]
+    requests: Any
+
+    def __init__(self, t8n: "T8N", stdin: Optional[Dict] = None):
+        if t8n.options.input_env == "stdin":
+            assert stdin is not None
+            data = stdin["env"]
+        else:
+            with open(t8n.options.input_env, "r") as f:
+                data = json.load(f)
+
+        self.coinbase = t8n.fork.hex_to_address(data["currentCoinbase"])
+        self.block_gas_limit = parse_hex_or_int(data["currentGasLimit"], Uint)
+        self.block_number = parse_hex_or_int(data["currentNumber"], Uint)
+        self.block_timestamp = parse_hex_or_int(data["currentTimestamp"], U256)
+
+        self.read_block_difficulty(data, t8n)
+        self.read_base_fee_per_gas(data, t8n)
+        self.read_randao(data, t8n)
+        self.read_block_hashes(data, t8n)
+        self.read_ommers(data, t8n)
+        self.read_withdrawals(data, t8n)
+
+        self.parent_beacon_block_root = None
+        if t8n.fork.is_after_fork("cancun"):
+            if not t8n.options.state_test:
+                parent_beacon_block_root_hex = data["parentBeaconBlockRoot"]
+                self.parent_beacon_block_root = (
+                    Bytes32(hex_to_bytes(parent_beacon_block_root_hex))
+                    if parent_beacon_block_root_hex is not None
+                    else None
+                )
+            self.read_excess_blob_gas(data, t8n)
+
+    def read_excess_blob_gas(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the excess_blob_gas from the data. If the excess blob gas is
+        not present, it is calculated from the parent block parameters.
+        """
+        self.parent_blob_gas_used = U64(0)
+        self.parent_excess_blob_gas = U64(0)
+        self.excess_blob_gas = None
+
+        if not t8n.fork.is_after_fork("cancun"):
+            return
+
+        if "parentExcessBlobGas" in data:
+            self.parent_excess_blob_gas = parse_hex_or_int(
+                data["parentExcessBlobGas"], U64
+            )
+
+        if "parentBlobGasUsed" in data:
+            self.parent_blob_gas_used = parse_hex_or_int(
+                data["parentBlobGasUsed"], U64
+            )
+
+        if "currentExcessBlobGas" in data:
+            self.excess_blob_gas = parse_hex_or_int(
+                data["currentExcessBlobGas"], U64
+            )
+            return
+
+        assert self.parent_excess_blob_gas is not None
+        assert self.parent_blob_gas_used is not None
+
+        arguments = {
+            # Useless as far as calculate_excess_blob_gas is concerned.
+            "parent_hash": Hash32(b"\0" * 32),
+            "ommers_hash": Hash32(b"\0" * 32),
+            "coinbase": Bytes20(b"\0" * 20),
+            "state_root": Hash32(b"\0" * 32),
+            "transactions_root": Hash32(b"\0" * 32),
+            "receipt_root": Hash32(b"\0" * 32),
+            "bloom": Bytes256(b"\0" * 256),
+            "difficulty": Uint(0),
+            "number": Uint(0),
+            "gas_limit": Uint(0),
+            "gas_used": Uint(0),
+            "timestamp": U256(0),
+            "extra_data": b"",
+            "prev_randao": Bytes32(b"\0" * 32),
+            "nonce": Bytes8(b"\0" * 8),
+            "withdrawals_root": Hash32(b"\0" * 32),
+            "parent_beacon_block_root": Hash32(b"\0" * 32),
+            # Used for calculating excess_blob_gas.
+            "base_fee_per_gas": self.parent_base_fee_per_gas,
+            "blob_gas_used": self.parent_blob_gas_used,
+            "excess_blob_gas": self.parent_excess_blob_gas,
+        }
+
+        if t8n.fork.is_after_fork("prague"):
+            arguments["requests_hash"] = Hash32(b"\0" * 32)
+
+        parent_header = t8n.fork.Header(**arguments)
+
+        self.excess_blob_gas = t8n.fork.calculate_excess_blob_gas(
+            parent_header
+        )
+
+    def read_base_fee_per_gas(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the base_fee_per_gas from the data. If the base fee is
+        not present, it is calculated from the parent block parameters.
+        """
+        self.parent_gas_used = None
+        self.parent_gas_limit = None
+        self.parent_base_fee_per_gas = None
+        self.base_fee_per_gas = None
+
+        if t8n.fork.is_after_fork("london"):
+            if "currentBaseFee" in data:
+                self.base_fee_per_gas = parse_hex_or_int(
+                    data["currentBaseFee"], Uint
+                )
+
+            if "parentGasUsed" in data:
+                self.parent_gas_used = parse_hex_or_int(
+                    data["parentGasUsed"], Uint
+                )
+
+            if "parentGasLimit" in data:
+                self.parent_gas_limit = parse_hex_or_int(
+                    data["parentGasLimit"], Uint
+                )
+
+            if "parentBaseFee" in data:
+                self.parent_base_fee_per_gas = parse_hex_or_int(
+                    data["parentBaseFee"], Uint
+                )
+
+            if self.base_fee_per_gas is None:
+                assert self.parent_gas_limit is not None
+                assert self.parent_gas_used is not None
+                assert self.parent_base_fee_per_gas is not None
+
+                parameters: List[object] = [
+                    self.block_gas_limit,
+                    self.parent_gas_limit,
+                    self.parent_gas_used,
+                    self.parent_base_fee_per_gas,
+                ]
+
+                self.base_fee_per_gas = t8n.fork.calculate_base_fee_per_gas(
+                    *parameters
+                )
+
+    def read_randao(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the randao from the data.
+        """
+        self.prev_randao = None
+        if t8n.fork.is_after_fork("paris"):
+            # tf tool might not always provide an
+            # even number of nibbles in the randao
+            # This could create issues in the
+            # hex_to_bytes function
+            current_random = data["currentRandom"]
+            if current_random.startswith("0x"):
+                current_random = current_random[2:]
+
+            if len(current_random) % 2 == 1:
+                current_random = "0" + current_random
+
+            self.prev_randao = Bytes32(
+                left_pad_zero_bytes(hex_to_bytes(current_random), 32)
+            )
+
+    def read_withdrawals(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the withdrawals from the data.
+        """
+        self.withdrawals = None
+        if t8n.fork.is_after_fork("shanghai"):
+            self.withdrawals = tuple(
+                t8n.json_to_withdrawals(wd) for wd in data["withdrawals"]
+            )
+
+    def read_block_difficulty(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the block difficulty from the data.
+        If `currentDifficulty` is present, it is used. Otherwise,
+        the difficulty is calculated from the parent block.
+        """
+        self.block_difficulty = None
+        self.parent_timestamp = None
+        self.parent_difficulty = None
+        self.parent_ommers_hash = None
+        if t8n.fork.is_after_fork("paris"):
+            return
+        elif "currentDifficulty" in data:
+            self.block_difficulty = parse_hex_or_int(
+                data["currentDifficulty"], Uint
+            )
+        else:
+            self.parent_timestamp = parse_hex_or_int(
+                data["parentTimestamp"], U256
+            )
+            self.parent_difficulty = parse_hex_or_int(
+                data["parentDifficulty"], Uint
+            )
+            args: List[object] = [
+                self.block_number,
+                self.block_timestamp,
+                self.parent_timestamp,
+                self.parent_difficulty,
+            ]
+            if t8n.fork.is_after_fork("byzantium"):
+                if "parentUncleHash" in data:
+                    EMPTY_OMMER_HASH = keccak256(rlp.encode([]))  # noqa N806
+                    self.parent_ommers_hash = Hash32(
+                        hex_to_bytes(data["parentUncleHash"])
+                    )
+                    parent_has_ommers = (
+                        self.parent_ommers_hash != EMPTY_OMMER_HASH
+                    )
+                    args.append(parent_has_ommers)
+                else:
+                    args.append(False)
+            self.block_difficulty = t8n.fork.calculate_block_difficulty(*args)
+
+    def read_block_hashes(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the block hashes. Returns a maximum of 256 block hashes.
+        """
+        self.parent_hash = None
+        if t8n.fork.is_after_fork("prague") and not t8n.options.state_test:
+            self.parent_hash = Hash32(hex_to_bytes(data["parentHash"]))
+
+        # Read the block hashes
+        block_hashes: List[Any] = []
+
+        # The hex key strings provided might not have standard formatting
+        clean_block_hashes: Dict[int, Hash32] = {}
+        if "blockHashes" in data:
+            for key, value in data["blockHashes"].items():
+                int_key = int(key, 16)
+                clean_block_hashes[int_key] = Hash32(hex_to_bytes(value))
+
+        # Store a maximum of 256 block hashes.
+        max_blockhash_count = min(Uint(256), self.block_number)
+        for number in range(
+            self.block_number - max_blockhash_count, self.block_number
+        ):
+            if number in clean_block_hashes.keys():
+                block_hashes.append(clean_block_hashes[number])
+            else:
+                block_hashes.append(None)
+
+        self.block_hashes = block_hashes
+
+    def read_ommers(self, data: Any, t8n: "T8N") -> None:
+        """
+        Read the ommers. The ommers data might not have all the details
+        needed to obtain the Header.
+        """
+        ommers = []
+        if "ommers" in data:
+            for ommer in data["ommers"]:
+                ommers.append(
+                    Ommer(
+                        ommer["delta"],
+                        t8n.fork.hex_to_address(ommer["address"]),
+                    )
+                )
+        self.ommers = ommers

ethereum_spec_tools/evm_tools/t8n/evm_trace/__init__.py

@@ -0,0 +1,5 @@
+"""
+EVM Trace Implementations.
+
+See [`ethereum.trace`](ref:ethereum.trace).
+"""

ethereum_spec_tools/evm_tools/t8n/evm_trace/count.py

@@ -0,0 +1,47 @@
+"""
+EVM trace implementation that counts how many times each opcode is executed.
+"""
+
+from collections import defaultdict
+
+from ethereum.trace import EvmTracer, OpStart, TraceEvent
+
+from .protocols import Evm
+
+
+class CountTracer(EvmTracer):
+    """
+    EVM trace implementation that counts how many times each opcode is
+    executed.
+    """
+
+    transaction_environment: object | None
+    active_traces: defaultdict[str, int]
+
+    def __init__(self) -> None:
+        self.transaction_environment = None
+        self.active_traces = defaultdict(lambda: 0)
+
+    def __call__(self, evm: object, event: TraceEvent) -> None:
+        """
+        Create a trace of the event.
+        """
+        if not isinstance(event, OpStart):
+            return
+
+        assert isinstance(evm, Evm)
+
+        if self.transaction_environment is not evm.message.tx_env:
+            self.active_traces = defaultdict(lambda: 0)
+            self.transaction_environment = evm.message.tx_env
+
+        self.active_traces[event.op.name] += 1
+
+    def results(self) -> dict[str, int]:
+        """
+        Return and clear the current opcode counts.
+        """
+        results = self.active_traces
+        self.active_traces = defaultdict(lambda: 0)
+        self.transaction_environment = None
+        return results

ethereum_spec_tools/evm_tools/t8n/evm_trace/eip3155.py

@@ -0,0 +1,333 @@
+"""
+The module implements the raw EVM tracer for t8n.
+"""
+
+import json
+import os
+from contextlib import ExitStack
+from dataclasses import asdict, dataclass, is_dataclass
+from typing import Any, List, Optional, TextIO, Union
+
+from ethereum.exceptions import EthereumException
+from ethereum.trace import (
+    EvmStop,
+    EvmTracer,
+    GasAndRefund,
+    OpEnd,
+    OpException,
+    OpStart,
+    PrecompileEnd,
+    PrecompileStart,
+    TraceEvent,
+    TransactionEnd,
+    TransactionStart,
+)
+
+from .protocols import Evm, EvmWithReturnData, TransactionEnvironment
+
+EXCLUDE_FROM_OUTPUT = ["gasCostTraced", "errorTraced", "precompile"]
+
+
+@dataclass
+class Trace:
+    """
+    The class implements the raw EVM trace.
+    """
+
+    pc: int
+    op: Optional[Union[str, int]]
+    gas: str
+    gasCost: str
+    memory: Optional[str]
+    memSize: int
+    stack: Optional[List[str]]
+    returnData: Optional[str]
+    depth: int
+    refund: int
+    opName: str
+    gasCostTraced: bool = False
+    errorTraced: bool = False
+    precompile: bool = False
+    error: Optional[str] = None
+
+
+@dataclass
+class FinalTrace:
+    """
+    The class implements final trace for a tx.
+    """
+
+    output: str
+    gasUsed: str
+    error: Optional[str] = None
+
+    def __init__(
+        self, gas_used: int, output: bytes, error: Optional[EthereumException]
+    ) -> None:
+        self.output = output.hex()
+        self.gasUsed = hex(gas_used)
+        if error:
+            self.error = type(error).__name__
+
+
+class Eip3155Tracer(EvmTracer):
+    """
+    EVM trace implementation compatible with EIP-3155.
+    """
+
+    transaction_environment: TransactionEnvironment | None
+    active_traces: list[Trace | FinalTrace]
+    trace_memory: bool
+    trace_stack: bool
+    trace_return_data: bool
+    output_basedir: str | TextIO
+
+    def __init__(
+        self,
+        /,
+        trace_memory: bool = False,
+        trace_stack: bool = True,
+        trace_return_data: bool = False,
+        output_basedir: str | TextIO = ".",
+    ):
+        self.transaction_environment = None
+        self.active_traces = []
+        self.trace_memory = trace_memory
+        self.trace_stack = trace_stack
+        self.trace_return_data = trace_return_data
+        self.output_basedir = output_basedir
+
+    def __call__(self, evm: Any, event: TraceEvent) -> None:
+        """
+        Create a trace of the event.
+        """
+        # System Transaction do not have a tx_hash or index
+        if (
+            evm.message.tx_env.index_in_block is None
+            or evm.message.tx_env.tx_hash is None
+        ):
+            return
+
+        assert isinstance(evm, Evm)
+
+        if self.transaction_environment is not evm.message.tx_env:
+            self.active_traces = []
+            self.transaction_environment = evm.message.tx_env
+
+        last_trace = None
+        if self.active_traces:
+            last_trace = self.active_traces[-1]
+
+        refund_counter = evm.refund_counter
+        parent_evm = evm.message.parent_evm
+        while parent_evm is not None:
+            refund_counter += parent_evm.refund_counter
+            parent_evm = parent_evm.message.parent_evm
+
+        len_memory = len(evm.memory)
+
+        return_data = None
+        if isinstance(evm, EvmWithReturnData) and self.trace_return_data:
+            return_data = "0x" + evm.return_data.hex()
+
+        memory = None
+        if self.trace_memory and len_memory > 0:
+            memory = "0x" + evm.memory.hex()
+
+        stack = None
+        if self.trace_stack:
+            stack = [hex(i) for i in evm.stack]
+
+        if isinstance(event, TransactionStart):
+            pass
+        elif isinstance(event, TransactionEnd):
+            final_trace = FinalTrace(event.gas_used, event.output, event.error)
+            self.active_traces.append(final_trace)
+
+            output_traces(
+                self.active_traces,
+                evm.message.tx_env.index_in_block,
+                evm.message.tx_env.tx_hash,
+                self.output_basedir,
+            )
+        elif isinstance(event, PrecompileStart):
+            new_trace = Trace(
+                pc=int(evm.pc),
+                op="0x" + event.address.hex().lstrip("0"),
+                gas=hex(evm.gas_left),
+                gasCost="0x0",
+                memory=memory,
+                memSize=len_memory,
+                stack=stack,
+                returnData=return_data,
+                depth=int(evm.message.depth) + 1,
+                refund=refund_counter,
+                opName="0x" + event.address.hex().lstrip("0"),
+                precompile=True,
+            )
+
+            self.active_traces.append(new_trace)
+        elif isinstance(event, PrecompileEnd):
+            assert isinstance(last_trace, Trace)
+
+            last_trace.gasCostTraced = True
+            last_trace.errorTraced = True
+        elif isinstance(event, OpStart):
+            op = event.op.value
+            if op == "InvalidOpcode":
+                op = "Invalid"
+            new_trace = Trace(
+                pc=int(evm.pc),
+                op=op,
+                gas=hex(evm.gas_left),
+                gasCost="0x0",
+                memory=memory,
+                memSize=len_memory,
+                stack=stack,
+                returnData=return_data,
+                depth=int(evm.message.depth) + 1,
+                refund=refund_counter,
+                opName=str(event.op).split(".")[-1],
+            )
+
+            self.active_traces.append(new_trace)
+        elif isinstance(event, OpEnd):
+            assert isinstance(last_trace, Trace)
+
+            last_trace.gasCostTraced = True
+            last_trace.errorTraced = True
+        elif isinstance(event, OpException):
+            if last_trace is not None:
+                assert isinstance(last_trace, Trace)
+            if (
+                # The first opcode in the code is an InvalidOpcode.
+                # So we add a new trace with InvalidOpcode as op.
+                not last_trace
+                # The current opcode is an InvalidOpcode. This condition
+                # is true if an InvalidOpcode is found in any location
+                # other than the first opcode.
+                or last_trace.errorTraced
+                # The first opcode in a child message is an InvalidOpcode.
+                # This case has to be explicitly handled since the first
+                # two conditions do not cover it.
+                or last_trace.depth == evm.message.depth
+            ):
+                if not hasattr(event.error, "code"):
+                    name = event.error.__class__.__name__
+                    raise TypeError(
+                        f"OpException event error type `{name}` does not "
+                        "have code"
+                    ) from event.error
+
+                new_trace = Trace(
+                    pc=int(evm.pc),
+                    op=event.error.code,
+                    gas=hex(evm.gas_left),
+                    gasCost="0x0",
+                    memory=memory,
+                    memSize=len_memory,
+                    stack=stack,
+                    returnData=return_data,
+                    depth=int(evm.message.depth) + 1,
+                    refund=refund_counter,
+                    opName="InvalidOpcode",
+                    gasCostTraced=True,
+                    errorTraced=True,
+                    error=type(event.error).__name__,
+                )
+
+                self.active_traces.append(new_trace)
+            elif not last_trace.errorTraced:
+                # If the error for the last trace is not covered
+                # the exception is attributed to the last trace.
+                last_trace.error = type(event.error).__name__
+                last_trace.errorTraced = True
+        elif isinstance(event, EvmStop):
+            if not evm.running:
+                return
+            elif len(evm.code) == 0:
+                return
+            else:
+                self(
+                    evm,
+                    OpStart(event.op),
+                )
+        elif isinstance(event, GasAndRefund):
+            if len(self.active_traces) == 0:
+                # In contract creation transactions, there may not be any
+                # traces
+                return
+
+            assert isinstance(last_trace, Trace)
+
+            if not last_trace.gasCostTraced:
+                last_trace.gasCost = hex(event.gas_cost)
+                last_trace.refund = refund_counter
+                last_trace.gasCostTraced = True
+
+
+class _TraceJsonEncoder(json.JSONEncoder):
+    @staticmethod
+    def retain(k: str, v: Optional[object]) -> bool:
+        if v is None:
+            return False
+
+        if k in EXCLUDE_FROM_OUTPUT:
+            return False
+
+        if k in ("pc", "gas", "gasCost", "refund"):
+            if isinstance(v, str) and int(v, 0).bit_length() > 64:
+                return False
+
+        return True
+
+    def default(self, obj: object) -> object:
+        if not is_dataclass(obj) or isinstance(obj, type):
+            return super().default(obj)
+
+        trace = {
+            k: v
+            for k, v in asdict(obj).items()
+            if _TraceJsonEncoder.retain(k, v)
+        }
+
+        return trace
+
+
+def output_op_trace(
+    trace: Union[Trace, FinalTrace], json_file: TextIO
+) -> None:
+    """
+    Output a single trace to a json file.
+    """
+    json.dump(trace, json_file, separators=(",", ":"), cls=_TraceJsonEncoder)
+    json_file.write("\n")
+
+
+def output_traces(
+    traces: List[Union[Trace, FinalTrace]],
+    index_in_block: int,
+    tx_hash: bytes,
+    output_basedir: str | TextIO,
+) -> None:
+    """
+    Output the traces to a json file.
+    """
+    with ExitStack() as stack:
+        json_file: TextIO
+
+        if isinstance(output_basedir, str):
+            tx_hash_str = "0x" + tx_hash.hex()
+            output_path = os.path.join(
+                output_basedir, f"trace-{index_in_block}-{tx_hash_str}.jsonl"
+            )
+            json_file = open(output_path, "w")
+            stack.push(json_file)
+        else:
+            json_file = output_basedir
+
+        for trace in traces:
+            if getattr(trace, "precompile", False):
+                # Traces related to pre-compile are not output.
+                continue
+            output_op_trace(trace, json_file)