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

ethereum/forks/osaka/utils/message.py

@@ -0,0 +1,90 @@
+"""
+Hardfork Utility Functions For The Message Data-structure.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Message specific functions used in this osaka version of
+specification.
+"""
+
+from ethereum_types.bytes import Bytes, Bytes0
+from ethereum_types.numeric import Uint
+
+from ..fork_types import Address
+from ..state import get_account
+from ..transactions import Transaction
+from ..vm import BlockEnvironment, Message, TransactionEnvironment
+from ..vm.precompiled_contracts.mapping import PRE_COMPILED_CONTRACTS
+from .address import compute_contract_address
+
+
+def prepare_message(
+    block_env: BlockEnvironment,
+    tx_env: TransactionEnvironment,
+    tx: Transaction,
+) -> Message:
+    """
+    Execute a transaction against the provided environment.
+
+    Parameters
+    ----------
+    block_env :
+        Environment for the Ethereum Virtual Machine.
+    tx_env :
+        Environment for the transaction.
+    tx :
+        Transaction to be executed.
+
+    Returns
+    -------
+    message: `ethereum.forks.osaka.vm.Message`
+        Items containing contract creation or message call specific data.
+
+    """
+    accessed_addresses = set()
+    accessed_addresses.add(tx_env.origin)
+    accessed_addresses.update(PRE_COMPILED_CONTRACTS.keys())
+    accessed_addresses.update(tx_env.access_list_addresses)
+
+    if isinstance(tx.to, Bytes0):
+        current_target = compute_contract_address(
+            tx_env.origin,
+            get_account(block_env.state, tx_env.origin).nonce - Uint(1),
+        )
+        msg_data = Bytes(b"")
+        code = tx.data
+        code_address = None
+    elif isinstance(tx.to, Address):
+        current_target = tx.to
+        msg_data = tx.data
+        code = get_account(block_env.state, tx.to).code
+        code_address = tx.to
+    else:
+        raise AssertionError("Target must be address or empty bytes")
+
+    accessed_addresses.add(current_target)
+
+    return Message(
+        block_env=block_env,
+        tx_env=tx_env,
+        caller=tx_env.origin,
+        target=tx.to,
+        gas=tx_env.gas,
+        value=tx.value,
+        data=msg_data,
+        code=code,
+        depth=Uint(0),
+        current_target=current_target,
+        code_address=code_address,
+        should_transfer_value=True,
+        is_static=False,
+        accessed_addresses=accessed_addresses,
+        accessed_storage_keys=set(tx_env.access_list_storage_keys),
+        disable_precompiles=False,
+        parent_evm=None,
+    )

ethereum/forks/osaka/vm/__init__.py

@@ -0,0 +1,191 @@
+"""
+Ethereum Virtual Machine (EVM).
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+The abstract computer which runs the code stored in an
+`.fork_types.Account`.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Set, Tuple
+
+from ethereum_types.bytes import Bytes, Bytes0, Bytes32
+from ethereum_types.numeric import U64, U256, Uint
+
+from ethereum.crypto.hash import Hash32
+from ethereum.exceptions import EthereumException
+
+from ..blocks import Log, Receipt, Withdrawal
+from ..fork_types import Address, Authorization, VersionedHash
+from ..state import State, TransientStorage
+from ..transactions import LegacyTransaction
+from ..trie import Trie
+
+__all__ = ("Environment", "Evm", "Message")
+
+
+@dataclass
+class BlockEnvironment:
+    """
+    Items external to the virtual machine itself, provided by the environment.
+    """
+
+    chain_id: U64
+    state: State
+    block_gas_limit: Uint
+    block_hashes: List[Hash32]
+    coinbase: Address
+    number: Uint
+    base_fee_per_gas: Uint
+    time: U256
+    prev_randao: Bytes32
+    excess_blob_gas: U64
+    parent_beacon_block_root: Hash32
+
+
+@dataclass
+class BlockOutput:
+    """
+    Output from applying the block body to the present state.
+
+    Contains the following:
+
+    block_gas_used : `ethereum.base_types.Uint`
+        Gas used for executing all transactions.
+    transactions_trie : `ethereum.fork_types.Root`
+        Trie of all the transactions in the block.
+    receipts_trie : `ethereum.fork_types.Root`
+        Trie root of all the receipts in the block.
+    receipt_keys :
+        Key of all the receipts in the block.
+    block_logs : `Bloom`
+        Logs bloom of all the logs included in all the transactions of the
+        block.
+    withdrawals_trie : `ethereum.fork_types.Root`
+        Trie root of all the withdrawals in the block.
+    blob_gas_used : `ethereum.base_types.U64`
+        Total blob gas used in the block.
+    requests : `Bytes`
+        Hash of all the requests in the block.
+    """
+
+    block_gas_used: Uint = Uint(0)
+    transactions_trie: Trie[Bytes, Optional[Bytes | LegacyTransaction]] = (
+        field(default_factory=lambda: Trie(secured=False, default=None))
+    )
+    receipts_trie: Trie[Bytes, Optional[Bytes | Receipt]] = field(
+        default_factory=lambda: Trie(secured=False, default=None)
+    )
+    receipt_keys: Tuple[Bytes, ...] = field(default_factory=tuple)
+    block_logs: Tuple[Log, ...] = field(default_factory=tuple)
+    withdrawals_trie: Trie[Bytes, Optional[Bytes | Withdrawal]] = field(
+        default_factory=lambda: Trie(secured=False, default=None)
+    )
+    blob_gas_used: U64 = U64(0)
+    requests: List[Bytes] = field(default_factory=list)
+
+
+@dataclass
+class TransactionEnvironment:
+    """
+    Items that are used by contract creation or message call.
+    """
+
+    origin: Address
+    gas_price: Uint
+    gas: Uint
+    access_list_addresses: Set[Address]
+    access_list_storage_keys: Set[Tuple[Address, Bytes32]]
+    transient_storage: TransientStorage
+    blob_versioned_hashes: Tuple[VersionedHash, ...]
+    authorizations: Tuple[Authorization, ...]
+    index_in_block: Optional[Uint]
+    tx_hash: Optional[Hash32]
+
+
+@dataclass
+class Message:
+    """
+    Items that are used by contract creation or message call.
+    """
+
+    block_env: BlockEnvironment
+    tx_env: TransactionEnvironment
+    caller: Address
+    target: Bytes0 | Address
+    current_target: Address
+    gas: Uint
+    value: U256
+    data: Bytes
+    code_address: Optional[Address]
+    code: Bytes
+    depth: Uint
+    should_transfer_value: bool
+    is_static: bool
+    accessed_addresses: Set[Address]
+    accessed_storage_keys: Set[Tuple[Address, Bytes32]]
+    disable_precompiles: bool
+    parent_evm: Optional["Evm"]
+
+
+@dataclass
+class Evm:
+    """The internal state of the virtual machine."""
+
+    pc: Uint
+    stack: List[U256]
+    memory: bytearray
+    code: Bytes
+    gas_left: Uint
+    valid_jump_destinations: Set[Uint]
+    logs: Tuple[Log, ...]
+    refund_counter: int
+    running: bool
+    message: Message
+    output: Bytes
+    accounts_to_delete: Set[Address]
+    return_data: Bytes
+    error: Optional[EthereumException]
+    accessed_addresses: Set[Address]
+    accessed_storage_keys: Set[Tuple[Address, Bytes32]]
+
+
+def incorporate_child_on_success(evm: Evm, child_evm: Evm) -> None:
+    """
+    Incorporate the state of a successful `child_evm` into the parent `evm`.
+
+    Parameters
+    ----------
+    evm :
+        The parent `EVM`.
+    child_evm :
+        The child evm to incorporate.
+
+    """
+    evm.gas_left += child_evm.gas_left
+    evm.logs += child_evm.logs
+    evm.refund_counter += child_evm.refund_counter
+    evm.accounts_to_delete.update(child_evm.accounts_to_delete)
+    evm.accessed_addresses.update(child_evm.accessed_addresses)
+    evm.accessed_storage_keys.update(child_evm.accessed_storage_keys)
+
+
+def incorporate_child_on_error(evm: Evm, child_evm: Evm) -> None:
+    """
+    Incorporate the state of an unsuccessful `child_evm` into the parent `evm`.
+
+    Parameters
+    ----------
+    evm :
+        The parent `EVM`.
+    child_evm :
+        The child evm to incorporate.
+
+    """
+    evm.gas_left += child_evm.gas_left

ethereum/forks/osaka/vm/eoa_delegation.py

@@ -0,0 +1,211 @@
+"""
+Set EOA account code.
+"""
+
+from typing import Optional, Tuple
+
+from ethereum_rlp import rlp
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import U64, U256, Uint
+
+from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
+from ethereum.crypto.hash import keccak256
+from ethereum.exceptions import InvalidBlock, InvalidSignatureError
+
+from ..fork_types import Address, Authorization
+from ..state import account_exists, get_account, increment_nonce, set_code
+from ..utils.hexadecimal import hex_to_address
+from ..vm.gas import GAS_COLD_ACCOUNT_ACCESS, GAS_WARM_ACCESS
+from . import Evm, Message
+
+SET_CODE_TX_MAGIC = b"\x05"
+EOA_DELEGATION_MARKER = b"\xef\x01\x00"
+EOA_DELEGATION_MARKER_LENGTH = len(EOA_DELEGATION_MARKER)
+EOA_DELEGATED_CODE_LENGTH = 23
+PER_EMPTY_ACCOUNT_COST = 25000
+PER_AUTH_BASE_COST = 12500
+NULL_ADDRESS = hex_to_address("0x0000000000000000000000000000000000000000")
+
+
+def is_valid_delegation(code: bytes) -> bool:
+    """
+    Whether the code is a valid delegation designation.
+
+    Parameters
+    ----------
+    code: `bytes`
+        The code to check.
+
+    Returns
+    -------
+    valid : `bool`
+        True if the code is a valid delegation designation,
+        False otherwise.
+
+    """
+    if (
+        len(code) == EOA_DELEGATED_CODE_LENGTH
+        and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER
+    ):
+        return True
+    return False
+
+
+def get_delegated_code_address(code: bytes) -> Optional[Address]:
+    """
+    Get the address to which the code delegates.
+
+    Parameters
+    ----------
+    code: `bytes`
+        The code to get the address from.
+
+    Returns
+    -------
+    address : `Optional[Address]`
+        The address of the delegated code.
+
+    """
+    if is_valid_delegation(code):
+        return Address(code[EOA_DELEGATION_MARKER_LENGTH:])
+    return None
+
+
+def recover_authority(authorization: Authorization) -> Address:
+    """
+    Recover the authority address from the authorization.
+
+    Parameters
+    ----------
+    authorization
+        The authorization to recover the authority from.
+
+    Raises
+    ------
+    InvalidSignatureError
+        If the signature is invalid.
+
+    Returns
+    -------
+    authority : `Address`
+        The recovered authority address.
+
+    """
+    y_parity, r, s = authorization.y_parity, authorization.r, authorization.s
+    if y_parity not in (0, 1):
+        raise InvalidSignatureError("Invalid y_parity in authorization")
+    if U256(0) >= r or r >= SECP256K1N:
+        raise InvalidSignatureError("Invalid r value in authorization")
+    if U256(0) >= s or s > SECP256K1N // U256(2):
+        raise InvalidSignatureError("Invalid s value in authorization")
+
+    signing_hash = keccak256(
+        SET_CODE_TX_MAGIC
+        + rlp.encode(
+            (
+                authorization.chain_id,
+                authorization.address,
+                authorization.nonce,
+            )
+        )
+    )
+
+    public_key = secp256k1_recover(r, s, U256(y_parity), signing_hash)
+    return Address(keccak256(public_key)[12:32])
+
+
+def access_delegation(
+    evm: Evm, address: Address
+) -> Tuple[bool, Address, Bytes, Uint]:
+    """
+    Get the delegation address, code, and the cost of access from the address.
+
+    Parameters
+    ----------
+    evm : `Evm`
+        The execution frame.
+    address : `Address`
+        The address to get the delegation from.
+
+    Returns
+    -------
+    delegation : `Tuple[bool, Address, Bytes, Uint]`
+        The delegation address, code, and access gas cost.
+
+    """
+    state = evm.message.block_env.state
+    code = get_account(state, address).code
+    if not is_valid_delegation(code):
+        return False, address, code, Uint(0)
+
+    address = Address(code[EOA_DELEGATION_MARKER_LENGTH:])
+    if address in evm.accessed_addresses:
+        access_gas_cost = GAS_WARM_ACCESS
+    else:
+        evm.accessed_addresses.add(address)
+        access_gas_cost = GAS_COLD_ACCOUNT_ACCESS
+    code = get_account(state, address).code
+
+    return True, address, code, access_gas_cost
+
+
+def set_delegation(message: Message) -> U256:
+    """
+    Set the delegation code for the authorities in the message.
+
+    Parameters
+    ----------
+    message :
+        Transaction specific items.
+    env :
+        External items required for EVM execution.
+
+    Returns
+    -------
+    refund_counter: `U256`
+        Refund from authority which already exists in state.
+
+    """
+    state = message.block_env.state
+    refund_counter = U256(0)
+    for auth in message.tx_env.authorizations:
+        if auth.chain_id not in (message.block_env.chain_id, U256(0)):
+            continue
+
+        if auth.nonce >= U64.MAX_VALUE:
+            continue
+
+        try:
+            authority = recover_authority(auth)
+        except InvalidSignatureError:
+            continue
+
+        message.accessed_addresses.add(authority)
+
+        authority_account = get_account(state, authority)
+        authority_code = authority_account.code
+
+        if authority_code and not is_valid_delegation(authority_code):
+            continue
+
+        authority_nonce = authority_account.nonce
+        if authority_nonce != auth.nonce:
+            continue
+
+        if account_exists(state, authority):
+            refund_counter += U256(PER_EMPTY_ACCOUNT_COST - PER_AUTH_BASE_COST)
+
+        if auth.address == NULL_ADDRESS:
+            code_to_set = b""
+        else:
+            code_to_set = EOA_DELEGATION_MARKER + auth.address
+        set_code(state, authority, code_to_set)
+
+        increment_nonce(state, authority)
+
+    if message.code_address is None:
+        raise InvalidBlock("Invalid type 4 transaction: no target")
+
+    message.code = get_account(state, message.code_address).code
+
+    return refund_counter

ethereum/forks/osaka/vm/exceptions.py

@@ -0,0 +1,139 @@
+"""
+Ethereum Virtual Machine (EVM) Exceptions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Exceptions which cause the EVM to halt exceptionally.
+"""
+
+from ethereum.exceptions import EthereumException
+
+
+class ExceptionalHalt(EthereumException):
+    """
+    Indicates that the EVM has experienced an exceptional halt. This causes
+    execution to immediately end with all gas being consumed.
+    """
+
+
+class Revert(EthereumException):
+    """
+    Raised by the `REVERT` opcode.
+
+    Unlike other EVM exceptions this does not result in the consumption of all
+    gas.
+    """
+
+    pass
+
+
+class StackUnderflowError(ExceptionalHalt):
+    """
+    Occurs when a pop is executed on an empty stack.
+    """
+
+    pass
+
+
+class StackOverflowError(ExceptionalHalt):
+    """
+    Occurs when a push is executed on a stack at max capacity.
+    """
+
+    pass
+
+
+class OutOfGasError(ExceptionalHalt):
+    """
+    Occurs when an operation costs more than the amount of gas left in the
+    frame.
+    """
+
+    pass
+
+
+class InvalidOpcode(ExceptionalHalt):
+    """
+    Raised when an invalid opcode is encountered.
+    """
+
+    code: int
+
+    def __init__(self, code: int) -> None:
+        super().__init__(code)
+        self.code = code
+
+
+class InvalidJumpDestError(ExceptionalHalt):
+    """
+    Occurs when the destination of a jump operation doesn't meet any of the
+    following criteria.
+
+      * The jump destination is less than the length of the code.
+      * The jump destination should have the `JUMPDEST` opcode (0x5B).
+      * The jump destination shouldn't be part of the data corresponding to
+        `PUSH-N` opcodes.
+    """
+
+
+class StackDepthLimitError(ExceptionalHalt):
+    """
+    Raised when the message depth is greater than `1024`.
+    """
+
+    pass
+
+
+class WriteInStaticContext(ExceptionalHalt):
+    """
+    Raised when an attempt is made to modify the state while operating inside
+    of a STATICCALL context.
+    """
+
+    pass
+
+
+class OutOfBoundsRead(ExceptionalHalt):
+    """
+    Raised when an attempt was made to read data beyond the
+    boundaries of the buffer.
+    """
+
+    pass
+
+
+class InvalidParameter(ExceptionalHalt):
+    """
+    Raised when invalid parameters are passed.
+    """
+
+    pass
+
+
+class InvalidContractPrefix(ExceptionalHalt):
+    """
+    Raised when the new contract code starts with 0xEF.
+    """
+
+    pass
+
+
+class AddressCollision(ExceptionalHalt):
+    """
+    Raised when the new contract address has a collision.
+    """
+
+    pass
+
+
+class KZGProofError(ExceptionalHalt):
+    """
+    Raised when the point evaluation precompile can't verify a proof.
+    """
+
+    pass