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

ethereum/forks/dao_fork/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utility functions unique to this particular fork.
+"""

ethereum/forks/dao_fork/utils/address.py

@@ -0,0 +1,62 @@
+"""
+Hardfork Utility Functions For Addresses.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Address specific functions used in this Dao Fork version of specification.
+"""
+
+from ethereum_rlp import rlp
+from ethereum_types.numeric import U256, Uint
+
+from ethereum.crypto.hash import keccak256
+from ethereum.utils.byte import left_pad_zero_bytes
+
+from ..fork_types import Address
+
+
+def to_address_masked(data: Uint | U256) -> Address:
+    """
+    Convert a Uint or U256 value to a valid address (20 bytes).
+
+    Parameters
+    ----------
+    data :
+        The numeric value to be converted to address.
+
+    Returns
+    -------
+    address : `Address`
+        The obtained address.
+
+    """
+    return Address(data.to_be_bytes32()[-20:])
+
+
+def compute_contract_address(address: Address, nonce: Uint) -> Address:
+    """
+    Computes address of the new account that needs to be created.
+
+    Parameters
+    ----------
+    address :
+        The address of the account that wants to create the new account.
+    nonce :
+        The transaction count of the account that wants to create the new
+        account.
+
+    Returns
+    -------
+    address: `ethereum.forks.dao_fork.fork_types.Address`
+        The computed address of the new account.
+
+    """
+    computed_address = keccak256(rlp.encode([address, nonce]))
+    canonical_address = computed_address[-20:]
+    padded_address = left_pad_zero_bytes(canonical_address, 20)
+    return Address(padded_address)

ethereum/forks/dao_fork/utils/hexadecimal.py

@@ -0,0 +1,55 @@
+"""
+Utility Functions For Hexadecimal Strings.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Hexadecimal utility functions used in this specification, specific to Dao Fork
+types.
+"""
+
+from ethereum_types.bytes import Bytes
+
+from ethereum.utils.hexadecimal import remove_hex_prefix
+
+from ..fork_types import Address, Root
+
+
+def hex_to_root(hex_string: str) -> Root:
+    """
+    Convert hex string to trie root.
+
+    Parameters
+    ----------
+    hex_string :
+        The hexadecimal string to be converted to trie root.
+
+    Returns
+    -------
+    root : `Root`
+        Trie root obtained from the given hexadecimal string.
+
+    """
+    return Root(Bytes.fromhex(remove_hex_prefix(hex_string)))
+
+
+def hex_to_address(hex_string: str) -> Address:
+    """
+    Convert hex string to Address (20 bytes).
+
+    Parameters
+    ----------
+    hex_string :
+        The hexadecimal string to be converted to Address.
+
+    Returns
+    -------
+    address : `Address`
+        The address obtained from the given hexadecimal string.
+
+    """
+    return Address(Bytes.fromhex(remove_hex_prefix(hex_string).rjust(40, "0")))

ethereum/forks/dao_fork/utils/message.py

@@ -0,0 +1,78 @@
+"""
+Hardfork Utility Functions For The Message Data-structure.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Message specific functions used in this Dao Fork 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 .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.dao_fork.vm.Message`
+        Items containing contract creation or message call specific data.
+
+    """
+    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")
+
+    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,
+        parent_evm=None,
+    )

ethereum/forks/dao_fork/vm/__init__.py

@@ -0,0 +1,163 @@
+"""
+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
+from ethereum_types.numeric import U64, U256, Uint
+
+from ethereum.crypto.hash import Hash32
+from ethereum.exceptions import EthereumException
+
+from ..blocks import Log, Receipt
+from ..fork_types import Address
+from ..state import State
+from ..transactions import Transaction
+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
+    time: U256
+    difficulty: Uint
+
+
+@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.
+    """
+
+    block_gas_used: Uint = Uint(0)
+    transactions_trie: Trie[Bytes, Optional[Transaction]] = field(
+        default_factory=lambda: Trie(secured=False, default=None)
+    )
+    receipts_trie: Trie[Bytes, Optional[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)
+
+
+@dataclass
+class TransactionEnvironment:
+    """
+    Items that are used by contract creation or message call.
+    """
+
+    origin: Address
+    gas_price: Uint
+    gas: Uint
+    index_in_block: 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
+    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]
+    error: Optional[EthereumException]
+
+
+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)
+
+
+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/dao_fork/vm/exceptions.py

@@ -0,0 +1,86 @@
+"""
+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 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 AddressCollision(ExceptionalHalt):
+    """
+    Raised when the new contract address has a collision.
+    """
+
+    pass

ethereum/forks/dao_fork/vm/gas.py

@@ -0,0 +1,212 @@
+"""
+Ethereum Virtual Machine (EVM) Gas.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+EVM gas constants and calculators.
+"""
+
+from dataclasses import dataclass
+from typing import List, Tuple
+
+from ethereum_types.numeric import U256, Uint
+
+from ethereum.trace import GasAndRefund, evm_trace
+from ethereum.utils.numeric import ceil32
+
+from ..fork_types import Address
+from ..state import State, account_exists
+from . import Evm
+from .exceptions import OutOfGasError
+
+GAS_JUMPDEST = Uint(1)
+GAS_BASE = Uint(2)
+GAS_VERY_LOW = Uint(3)
+GAS_SLOAD = Uint(50)
+GAS_STORAGE_SET = Uint(20000)
+GAS_STORAGE_UPDATE = Uint(5000)
+GAS_STORAGE_CLEAR_REFUND = Uint(15000)
+GAS_LOW = Uint(5)
+GAS_MID = Uint(8)
+GAS_HIGH = Uint(10)
+GAS_EXPONENTIATION = Uint(10)
+GAS_EXPONENTIATION_PER_BYTE = Uint(10)
+GAS_MEMORY = Uint(3)
+GAS_KECCAK256 = Uint(30)
+GAS_KECCAK256_WORD = Uint(6)
+GAS_COPY = Uint(3)
+GAS_BLOCK_HASH = Uint(20)
+GAS_EXTERNAL = Uint(20)
+GAS_BALANCE = Uint(20)
+GAS_LOG = Uint(375)
+GAS_LOG_DATA = Uint(8)
+GAS_LOG_TOPIC = Uint(375)
+GAS_CREATE = Uint(32000)
+GAS_CODE_DEPOSIT = Uint(200)
+GAS_ZERO = Uint(0)
+GAS_CALL = Uint(40)
+GAS_NEW_ACCOUNT = Uint(25000)
+GAS_CALL_VALUE = Uint(9000)
+GAS_CALL_STIPEND = Uint(2300)
+REFUND_SELF_DESTRUCT = Uint(24000)
+GAS_ECRECOVER = Uint(3000)
+GAS_SHA256 = Uint(60)
+GAS_SHA256_WORD = Uint(12)
+GAS_RIPEMD160 = Uint(600)
+GAS_RIPEMD160_WORD = Uint(120)
+GAS_IDENTITY = Uint(15)
+GAS_IDENTITY_WORD = Uint(3)
+
+
+@dataclass
+class ExtendMemory:
+    """
+    Define the parameters for memory extension in opcodes.
+
+    `cost`: `ethereum.base_types.Uint`
+        The gas required to perform the extension
+    `expand_by`: `ethereum.base_types.Uint`
+        The size by which the memory will be extended
+    """
+
+    cost: Uint
+    expand_by: Uint
+
+
+@dataclass
+class MessageCallGas:
+    """
+    Define the gas cost and gas given to the sub-call for
+    executing the call opcodes.
+
+    `cost`: `ethereum.base_types.Uint`
+        The gas required to execute the call opcode, excludes
+        memory expansion costs.
+    `sub_call`: `ethereum.base_types.Uint`
+        The portion of gas available to sub-calls that is refundable
+        if not consumed.
+    """
+
+    cost: Uint
+    sub_call: Uint
+
+
+def charge_gas(evm: Evm, amount: Uint) -> None:
+    """
+    Subtracts `amount` from `evm.gas_left`.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM.
+    amount :
+        The amount of gas the current operation requires.
+
+    """
+    evm_trace(evm, GasAndRefund(int(amount)))
+
+    if evm.gas_left < amount:
+        raise OutOfGasError
+    else:
+        evm.gas_left -= amount
+
+
+def calculate_memory_gas_cost(size_in_bytes: Uint) -> Uint:
+    """
+    Calculates the gas cost for allocating memory
+    to the smallest multiple of 32 bytes,
+    such that the allocated size is at least as big as the given size.
+
+    Parameters
+    ----------
+    size_in_bytes :
+        The size of the data in bytes.
+
+    Returns
+    -------
+    total_gas_cost : `ethereum.base_types.Uint`
+        The gas cost for storing data in memory.
+
+    """
+    size_in_words = ceil32(size_in_bytes) // Uint(32)
+    linear_cost = size_in_words * GAS_MEMORY
+    quadratic_cost = size_in_words ** Uint(2) // Uint(512)
+    total_gas_cost = linear_cost + quadratic_cost
+    try:
+        return total_gas_cost
+    except ValueError as e:
+        raise OutOfGasError from e
+
+
+def calculate_gas_extend_memory(
+    memory: bytearray, extensions: List[Tuple[U256, U256]]
+) -> ExtendMemory:
+    """
+    Calculates the gas amount to extend memory.
+
+    Parameters
+    ----------
+    memory :
+        Memory contents of the EVM.
+    extensions:
+        List of extensions to be made to the memory.
+        Consists of a tuple of start position and size.
+
+    Returns
+    -------
+    extend_memory: `ExtendMemory`
+
+    """
+    size_to_extend = Uint(0)
+    to_be_paid = Uint(0)
+    current_size = Uint(len(memory))
+    for start_position, size in extensions:
+        if size == 0:
+            continue
+        before_size = ceil32(current_size)
+        after_size = ceil32(Uint(start_position) + Uint(size))
+        if after_size <= before_size:
+            continue
+
+        size_to_extend += after_size - before_size
+        already_paid = calculate_memory_gas_cost(before_size)
+        total_cost = calculate_memory_gas_cost(after_size)
+        to_be_paid += total_cost - already_paid
+
+        current_size = after_size
+
+    return ExtendMemory(to_be_paid, size_to_extend)
+
+
+def calculate_message_call_gas(
+    state: State, gas: Uint, to: Address, value: U256
+) -> MessageCallGas:
+    """
+    Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`.
+
+    Parameters
+    ----------
+    state :
+        The current state.
+    gas :
+        The amount of gas provided to the message-call.
+    to:
+        The address of the recipient account.
+    value:
+        The amount of `ETH` that needs to be transferred.
+
+    Returns
+    -------
+    message_call_gas: `MessageCallGas`
+
+    """
+    create_gas_cost = Uint(0) if account_exists(state, to) else GAS_NEW_ACCOUNT
+    transfer_gas_cost = Uint(0) if value == 0 else GAS_CALL_VALUE
+    cost = GAS_CALL + gas + create_gas_cost + transfer_gas_cost
+    stipend = gas if value == 0 else GAS_CALL_STIPEND + gas
+    return MessageCallGas(cost, stipend)