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

ethereum/forks/dao_fork/vm/instructions/system.py

@@ -0,0 +1,457 @@
+"""
+Ethereum Virtual Machine (EVM) System Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM system related instructions.
+"""
+
+from ethereum_types.bytes import Bytes0
+from ethereum_types.numeric import U256, Uint
+
+from ...fork_types import Address
+from ...state import (
+    account_has_code_or_nonce,
+    account_has_storage,
+    get_account,
+    increment_nonce,
+    set_account_balance,
+)
+from ...utils.address import compute_contract_address, to_address_masked
+from .. import (
+    Evm,
+    Message,
+    incorporate_child_on_error,
+    incorporate_child_on_success,
+)
+from ..gas import (
+    GAS_CALL,
+    GAS_CREATE,
+    GAS_ZERO,
+    REFUND_SELF_DESTRUCT,
+    calculate_gas_extend_memory,
+    calculate_message_call_gas,
+    charge_gas,
+)
+from ..memory import memory_read_bytes, memory_write
+from ..stack import pop, push
+
+
+def create(evm: Evm) -> None:
+    """
+    Creates a new account with associated code.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # This import causes a circular import error
+    # if it's not moved inside this method
+    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_create_message
+
+    # STACK
+    endowment = pop(evm.stack)
+    memory_start_position = pop(evm.stack)
+    memory_size = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_position, memory_size)]
+    )
+
+    charge_gas(evm, GAS_CREATE + extend_memory.cost)
+
+    create_message_gas = evm.gas_left
+    evm.gas_left = Uint(0)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    sender_address = evm.message.current_target
+    sender = get_account(evm.message.block_env.state, sender_address)
+
+    contract_address = compute_contract_address(
+        evm.message.current_target,
+        get_account(
+            evm.message.block_env.state, evm.message.current_target
+        ).nonce,
+    )
+
+    if (
+        sender.balance < endowment
+        or sender.nonce == Uint(2**64 - 1)
+        or evm.message.depth + Uint(1) > STACK_DEPTH_LIMIT
+    ):
+        push(evm.stack, U256(0))
+        evm.gas_left += create_message_gas
+    elif account_has_code_or_nonce(
+        evm.message.block_env.state, contract_address
+    ) or account_has_storage(evm.message.block_env.state, contract_address):
+        increment_nonce(
+            evm.message.block_env.state, evm.message.current_target
+        )
+        push(evm.stack, U256(0))
+    else:
+        call_data = memory_read_bytes(
+            evm.memory, memory_start_position, memory_size
+        )
+
+        increment_nonce(
+            evm.message.block_env.state, evm.message.current_target
+        )
+
+        child_message = Message(
+            block_env=evm.message.block_env,
+            tx_env=evm.message.tx_env,
+            caller=evm.message.current_target,
+            target=Bytes0(),
+            gas=create_message_gas,
+            value=endowment,
+            data=b"",
+            code=call_data,
+            current_target=contract_address,
+            depth=evm.message.depth + Uint(1),
+            code_address=None,
+            should_transfer_value=True,
+            parent_evm=evm,
+        )
+        child_evm = process_create_message(child_message)
+
+        if child_evm.error:
+            incorporate_child_on_error(evm, child_evm)
+            push(evm.stack, U256(0))
+        else:
+            incorporate_child_on_success(evm, child_evm)
+            push(
+                evm.stack, U256.from_be_bytes(child_evm.message.current_target)
+            )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def return_(evm: Evm) -> None:
+    """
+    Halts execution returning output data.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    memory_start_position = pop(evm.stack)
+    memory_size = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_position, memory_size)]
+    )
+
+    charge_gas(evm, GAS_ZERO + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    evm.output = memory_read_bytes(
+        evm.memory, memory_start_position, memory_size
+    )
+
+    evm.running = False
+
+    # PROGRAM COUNTER
+    pass
+
+
+def generic_call(
+    evm: Evm,
+    gas: Uint,
+    value: U256,
+    caller: Address,
+    to: Address,
+    code_address: Address,
+    should_transfer_value: bool,
+    memory_input_start_position: U256,
+    memory_input_size: U256,
+    memory_output_start_position: U256,
+    memory_output_size: U256,
+) -> None:
+    """
+    Perform the core logic of the `CALL*` family of opcodes.
+    """
+    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_message
+
+    if evm.message.depth + Uint(1) > STACK_DEPTH_LIMIT:
+        evm.gas_left += gas
+        push(evm.stack, U256(0))
+        return
+
+    call_data = memory_read_bytes(
+        evm.memory, memory_input_start_position, memory_input_size
+    )
+    code = get_account(evm.message.block_env.state, code_address).code
+    child_message = Message(
+        block_env=evm.message.block_env,
+        tx_env=evm.message.tx_env,
+        caller=caller,
+        target=to,
+        gas=gas,
+        value=value,
+        data=call_data,
+        code=code,
+        current_target=to,
+        depth=evm.message.depth + Uint(1),
+        code_address=code_address,
+        should_transfer_value=should_transfer_value,
+        parent_evm=evm,
+    )
+    child_evm = process_message(child_message)
+
+    if child_evm.error:
+        incorporate_child_on_error(evm, child_evm)
+        push(evm.stack, U256(0))
+    else:
+        incorporate_child_on_success(evm, child_evm)
+        push(evm.stack, U256(1))
+
+    actual_output_size = min(memory_output_size, U256(len(child_evm.output)))
+    memory_write(
+        evm.memory,
+        memory_output_start_position,
+        child_evm.output[:actual_output_size],
+    )
+
+
+def call(evm: Evm) -> None:
+    """
+    Message-call into an account.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    gas = Uint(pop(evm.stack))
+    to = to_address_masked(pop(evm.stack))
+    value = pop(evm.stack)
+    memory_input_start_position = pop(evm.stack)
+    memory_input_size = pop(evm.stack)
+    memory_output_start_position = pop(evm.stack)
+    memory_output_size = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory,
+        [
+            (memory_input_start_position, memory_input_size),
+            (memory_output_start_position, memory_output_size),
+        ],
+    )
+
+    code_address = to
+
+    message_call_gas = calculate_message_call_gas(
+        evm.message.block_env.state, gas, to, value
+    )
+    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    sender_balance = get_account(
+        evm.message.block_env.state, evm.message.current_target
+    ).balance
+    if sender_balance < value:
+        push(evm.stack, U256(0))
+        evm.gas_left += message_call_gas.sub_call
+    else:
+        generic_call(
+            evm,
+            message_call_gas.sub_call,
+            value,
+            evm.message.current_target,
+            to,
+            code_address,
+            True,
+            memory_input_start_position,
+            memory_input_size,
+            memory_output_start_position,
+            memory_output_size,
+        )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def callcode(evm: Evm) -> None:
+    """
+    Message-call into this account with alternative account’s code.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    gas = Uint(pop(evm.stack))
+    code_address = to_address_masked(pop(evm.stack))
+    value = pop(evm.stack)
+    memory_input_start_position = pop(evm.stack)
+    memory_input_size = pop(evm.stack)
+    memory_output_start_position = pop(evm.stack)
+    memory_output_size = pop(evm.stack)
+
+    # GAS
+    to = evm.message.current_target
+
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory,
+        [
+            (memory_input_start_position, memory_input_size),
+            (memory_output_start_position, memory_output_size),
+        ],
+    )
+    message_call_gas = calculate_message_call_gas(
+        evm.message.block_env.state, gas, to, value
+    )
+    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    sender_balance = get_account(
+        evm.message.block_env.state, evm.message.current_target
+    ).balance
+    if sender_balance < value:
+        push(evm.stack, U256(0))
+        evm.gas_left += message_call_gas.sub_call
+    else:
+        generic_call(
+            evm,
+            message_call_gas.sub_call,
+            value,
+            evm.message.current_target,
+            to,
+            code_address,
+            True,
+            memory_input_start_position,
+            memory_input_size,
+            memory_output_start_position,
+            memory_output_size,
+        )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def selfdestruct(evm: Evm) -> None:
+    """
+    Halt execution and register account for later deletion.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    beneficiary = to_address_masked(pop(evm.stack))
+
+    # GAS
+    gas_cost = GAS_ZERO
+
+    originator = evm.message.current_target
+
+    refunded_accounts = evm.accounts_to_delete
+    parent_evm = evm.message.parent_evm
+    while parent_evm is not None:
+        refunded_accounts.update(parent_evm.accounts_to_delete)
+        parent_evm = parent_evm.message.parent_evm
+
+    if originator not in refunded_accounts:
+        evm.refund_counter += int(REFUND_SELF_DESTRUCT)
+
+    charge_gas(evm, gas_cost)
+
+    # OPERATION
+    beneficiary_balance = get_account(
+        evm.message.block_env.state, beneficiary
+    ).balance
+    originator_balance = get_account(
+        evm.message.block_env.state, originator
+    ).balance
+
+    # First Transfer to beneficiary
+    set_account_balance(
+        evm.message.block_env.state,
+        beneficiary,
+        beneficiary_balance + originator_balance,
+    )
+    # Next, Zero the balance of the address being deleted (must come after
+    # sending to beneficiary in case the contract named itself as the
+    # beneficiary).
+    set_account_balance(evm.message.block_env.state, originator, U256(0))
+
+    # register account for deletion
+    evm.accounts_to_delete.add(originator)
+
+    # HALT the execution
+    evm.running = False
+
+    # PROGRAM COUNTER
+    pass
+
+
+def delegatecall(evm: Evm) -> None:
+    """
+    Message-call into an account.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    gas = Uint(pop(evm.stack))
+    code_address = to_address_masked(pop(evm.stack))
+    memory_input_start_position = pop(evm.stack)
+    memory_input_size = pop(evm.stack)
+    memory_output_start_position = pop(evm.stack)
+    memory_output_size = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory,
+        [
+            (memory_input_start_position, memory_input_size),
+            (memory_output_start_position, memory_output_size),
+        ],
+    )
+    charge_gas(evm, GAS_CALL + gas + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    generic_call(
+        evm,
+        gas,
+        evm.message.value,
+        evm.message.caller,
+        evm.message.current_target,
+        code_address,
+        False,
+        memory_input_start_position,
+        memory_input_size,
+        memory_output_start_position,
+        memory_output_size,
+    )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)

ethereum/forks/dao_fork/vm/interpreter.py

@@ -0,0 +1,274 @@
+"""
+Ethereum Virtual Machine (EVM) Interpreter.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+A straightforward interpreter that executes EVM code.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Set, Tuple
+
+from ethereum_types.bytes import Bytes0
+from ethereum_types.numeric import U256, Uint, ulen
+
+from ethereum.exceptions import EthereumException
+from ethereum.trace import (
+    EvmStop,
+    OpEnd,
+    OpException,
+    OpStart,
+    PrecompileEnd,
+    PrecompileStart,
+    TransactionEnd,
+    evm_trace,
+)
+
+from ..blocks import Log
+from ..fork_types import Address
+from ..state import (
+    account_has_code_or_nonce,
+    account_has_storage,
+    begin_transaction,
+    commit_transaction,
+    destroy_storage,
+    move_ether,
+    rollback_transaction,
+    set_code,
+    touch_account,
+)
+from ..vm import Message
+from ..vm.gas import GAS_CODE_DEPOSIT, charge_gas
+from ..vm.precompiled_contracts.mapping import PRE_COMPILED_CONTRACTS
+from . import Evm
+from .exceptions import (
+    AddressCollision,
+    ExceptionalHalt,
+    InvalidOpcode,
+    StackDepthLimitError,
+)
+from .instructions import Ops, op_implementation
+from .runtime import get_valid_jump_destinations
+
+STACK_DEPTH_LIMIT = Uint(1024)
+
+
+@dataclass
+class MessageCallOutput:
+    """
+    Output of a particular message call.
+
+    Contains the following:
+
+          1. `gas_left`: remaining gas after execution.
+          2. `refund_counter`: gas to refund after execution.
+          3. `logs`: list of `Log` generated during execution.
+          4. `accounts_to_delete`: Contracts which have self-destructed.
+          5. `error`: The error from the execution if any.
+    """
+
+    gas_left: Uint
+    refund_counter: U256
+    logs: Tuple[Log, ...]
+    accounts_to_delete: Set[Address]
+    error: Optional[EthereumException]
+
+
+def process_message_call(message: Message) -> MessageCallOutput:
+    """
+    If `message.target` is empty then it creates a smart contract
+    else it executes a call from the `message.caller` to the `message.target`.
+
+    Parameters
+    ----------
+    message :
+        Transaction specific items.
+
+    Returns
+    -------
+    output : `MessageCallOutput`
+        Output of the message call
+
+    """
+    block_env = message.block_env
+    refund_counter = U256(0)
+    if message.target == Bytes0(b""):
+        is_collision = account_has_code_or_nonce(
+            block_env.state, message.current_target
+        ) or account_has_storage(block_env.state, message.current_target)
+        if is_collision:
+            return MessageCallOutput(
+                Uint(0), U256(0), tuple(), set(), AddressCollision()
+            )
+        else:
+            evm = process_create_message(message)
+    else:
+        evm = process_message(message)
+
+    if evm.error:
+        logs: Tuple[Log, ...] = ()
+        accounts_to_delete = set()
+    else:
+        logs = evm.logs
+        accounts_to_delete = evm.accounts_to_delete
+        refund_counter += U256(evm.refund_counter)
+
+    tx_end = TransactionEnd(
+        int(message.gas) - int(evm.gas_left), evm.output, evm.error
+    )
+    evm_trace(evm, tx_end)
+
+    return MessageCallOutput(
+        gas_left=evm.gas_left,
+        refund_counter=refund_counter,
+        logs=logs,
+        accounts_to_delete=accounts_to_delete,
+        error=evm.error,
+    )
+
+
+def process_create_message(message: Message) -> Evm:
+    """
+    Executes a call to create a smart contract.
+
+    Parameters
+    ----------
+    message :
+        Transaction specific items.
+
+    Returns
+    -------
+    evm: :py:class:`~ethereum.forks.dao_fork.vm.Evm`
+        Items containing execution specific objects.
+
+    """
+    state = message.block_env.state
+    # take snapshot of state before processing the message
+    begin_transaction(state)
+
+    # If the address where the account is being created has storage, it is
+    # destroyed. This can only happen in the following highly unlikely
+    # circumstances:
+    # * The address created by two `CREATE` calls collide.
+    # * The first `CREATE` left empty code.
+    destroy_storage(state, message.current_target)
+
+    evm = process_message(message)
+    if not evm.error:
+        contract_code = evm.output
+        contract_code_gas = Uint(len(contract_code)) * GAS_CODE_DEPOSIT
+        try:
+            charge_gas(evm, contract_code_gas)
+        except ExceptionalHalt as error:
+            rollback_transaction(state)
+            evm.gas_left = Uint(0)
+            evm.error = error
+        else:
+            set_code(state, message.current_target, contract_code)
+            commit_transaction(state)
+    else:
+        rollback_transaction(state)
+    return evm
+
+
+def process_message(message: Message) -> Evm:
+    """
+    Move ether and execute the relevant code.
+
+    Parameters
+    ----------
+    message :
+        Transaction specific items.
+
+    Returns
+    -------
+    evm: :py:class:`~ethereum.forks.dao_fork.vm.Evm`
+        Items containing execution specific objects
+
+    """
+    state = message.block_env.state
+    if message.depth > STACK_DEPTH_LIMIT:
+        raise StackDepthLimitError("Stack depth limit reached")
+
+    # take snapshot of state before processing the message
+    begin_transaction(state)
+
+    touch_account(state, message.current_target)
+
+    if message.should_transfer_value and message.value != 0:
+        move_ether(
+            state, message.caller, message.current_target, message.value
+        )
+
+    evm = execute_code(message)
+    if evm.error:
+        # revert state to the last saved checkpoint
+        # since the message call resulted in an error
+        rollback_transaction(state)
+    else:
+        commit_transaction(state)
+    return evm
+
+
+def execute_code(message: Message) -> Evm:
+    """
+    Executes bytecode present in the `message`.
+
+    Parameters
+    ----------
+    message :
+        Transaction specific items.
+
+    Returns
+    -------
+    evm: `ethereum.vm.EVM`
+        Items containing execution specific objects
+
+    """
+    code = message.code
+    valid_jump_destinations = get_valid_jump_destinations(code)
+
+    evm = Evm(
+        pc=Uint(0),
+        stack=[],
+        memory=bytearray(),
+        code=code,
+        gas_left=message.gas,
+        valid_jump_destinations=valid_jump_destinations,
+        logs=(),
+        refund_counter=0,
+        running=True,
+        message=message,
+        output=b"",
+        accounts_to_delete=set(),
+        error=None,
+    )
+    try:
+        if evm.message.code_address in PRE_COMPILED_CONTRACTS:
+            evm_trace(evm, PrecompileStart(evm.message.code_address))
+            PRE_COMPILED_CONTRACTS[evm.message.code_address](evm)
+            evm_trace(evm, PrecompileEnd())
+            return evm
+
+        while evm.running and evm.pc < ulen(evm.code):
+            try:
+                op = Ops(evm.code[evm.pc])
+            except ValueError as e:
+                raise InvalidOpcode(evm.code[evm.pc]) from e
+
+            evm_trace(evm, OpStart(op))
+            op_implementation[op](evm)
+            evm_trace(evm, OpEnd())
+
+        evm_trace(evm, EvmStop(Ops.STOP))
+
+    except ExceptionalHalt as error:
+        evm_trace(evm, OpException(error))
+        evm.gas_left = Uint(0)
+        evm.error = error
+    return evm