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

ethereum/forks/frontier/vm/instructions/stack.py

@@ -0,0 +1,204 @@
+"""
+Ethereum Virtual Machine (EVM) Stack Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM stack related instructions.
+"""
+
+from functools import partial
+
+from ethereum_types.numeric import U256, Uint
+
+from .. import Evm, stack
+from ..exceptions import StackUnderflowError
+from ..gas import GAS_BASE, GAS_VERY_LOW, charge_gas
+from ..memory import buffer_read
+
+
+def pop(evm: Evm) -> None:
+    """
+    Remove item from stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    stack.pop(evm.stack)
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    pass
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def push_n(evm: Evm, num_bytes: int) -> None:
+    """
+    Pushes a N-byte immediate onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    num_bytes :
+        The number of immediate bytes to be read from the code and pushed to
+        the stack.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_VERY_LOW)
+
+    # OPERATION
+    data_to_push = U256.from_be_bytes(
+        buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(num_bytes))
+    )
+    stack.push(evm.stack, data_to_push)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1) + Uint(num_bytes)
+
+
+def dup_n(evm: Evm, item_number: int) -> None:
+    """
+    Duplicate the Nth stack item (from top of the stack) to the top of stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    item_number :
+        The stack item number (0-indexed from top of stack) to be duplicated
+        to the top of stack.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_VERY_LOW)
+    if item_number >= len(evm.stack):
+        raise StackUnderflowError
+    data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number]
+    stack.push(evm.stack, data_to_duplicate)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def swap_n(evm: Evm, item_number: int) -> None:
+    """
+    Swap the top and the `item_number` element of the stack, where
+    the top of the stack is position zero.
+
+    If `item_number` is zero, this function does nothing (which should not be
+    possible, since there is no `SWAP0` instruction).
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    item_number :
+        The stack item number (0-indexed from top of stack) to be swapped
+        with the top of stack element.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_VERY_LOW)
+    if item_number >= len(evm.stack):
+        raise StackUnderflowError
+    evm.stack[-1], evm.stack[-1 - item_number] = (
+        evm.stack[-1 - item_number],
+        evm.stack[-1],
+    )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+push1 = partial(push_n, num_bytes=1)
+push2 = partial(push_n, num_bytes=2)
+push3 = partial(push_n, num_bytes=3)
+push4 = partial(push_n, num_bytes=4)
+push5 = partial(push_n, num_bytes=5)
+push6 = partial(push_n, num_bytes=6)
+push7 = partial(push_n, num_bytes=7)
+push8 = partial(push_n, num_bytes=8)
+push9 = partial(push_n, num_bytes=9)
+push10 = partial(push_n, num_bytes=10)
+push11 = partial(push_n, num_bytes=11)
+push12 = partial(push_n, num_bytes=12)
+push13 = partial(push_n, num_bytes=13)
+push14 = partial(push_n, num_bytes=14)
+push15 = partial(push_n, num_bytes=15)
+push16 = partial(push_n, num_bytes=16)
+push17 = partial(push_n, num_bytes=17)
+push18 = partial(push_n, num_bytes=18)
+push19 = partial(push_n, num_bytes=19)
+push20 = partial(push_n, num_bytes=20)
+push21 = partial(push_n, num_bytes=21)
+push22 = partial(push_n, num_bytes=22)
+push23 = partial(push_n, num_bytes=23)
+push24 = partial(push_n, num_bytes=24)
+push25 = partial(push_n, num_bytes=25)
+push26 = partial(push_n, num_bytes=26)
+push27 = partial(push_n, num_bytes=27)
+push28 = partial(push_n, num_bytes=28)
+push29 = partial(push_n, num_bytes=29)
+push30 = partial(push_n, num_bytes=30)
+push31 = partial(push_n, num_bytes=31)
+push32 = partial(push_n, num_bytes=32)
+
+dup1 = partial(dup_n, item_number=0)
+dup2 = partial(dup_n, item_number=1)
+dup3 = partial(dup_n, item_number=2)
+dup4 = partial(dup_n, item_number=3)
+dup5 = partial(dup_n, item_number=4)
+dup6 = partial(dup_n, item_number=5)
+dup7 = partial(dup_n, item_number=6)
+dup8 = partial(dup_n, item_number=7)
+dup9 = partial(dup_n, item_number=8)
+dup10 = partial(dup_n, item_number=9)
+dup11 = partial(dup_n, item_number=10)
+dup12 = partial(dup_n, item_number=11)
+dup13 = partial(dup_n, item_number=12)
+dup14 = partial(dup_n, item_number=13)
+dup15 = partial(dup_n, item_number=14)
+dup16 = partial(dup_n, item_number=15)
+
+swap1 = partial(swap_n, item_number=1)
+swap2 = partial(swap_n, item_number=2)
+swap3 = partial(swap_n, item_number=3)
+swap4 = partial(swap_n, item_number=4)
+swap5 = partial(swap_n, item_number=5)
+swap6 = partial(swap_n, item_number=6)
+swap7 = partial(swap_n, item_number=7)
+swap8 = partial(swap_n, item_number=8)
+swap9 = partial(swap_n, item_number=9)
+swap10 = partial(swap_n, item_number=10)
+swap11 = partial(swap_n, item_number=11)
+swap12 = partial(swap_n, item_number=12)
+swap13 = partial(swap_n, item_number=13)
+swap14 = partial(swap_n, item_number=14)
+swap15 = partial(swap_n, item_number=15)
+swap16 = partial(swap_n, item_number=16)

ethereum/forks/frontier/vm/instructions/storage.py

@@ -0,0 +1,87 @@
+"""
+Ethereum Virtual Machine (EVM) Storage Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM storage related instructions.
+"""
+
+from ethereum_types.numeric import Uint
+
+from ...state import get_storage, set_storage
+from .. import Evm
+from ..gas import (
+    GAS_SLOAD,
+    GAS_STORAGE_CLEAR_REFUND,
+    GAS_STORAGE_SET,
+    GAS_STORAGE_UPDATE,
+    charge_gas,
+)
+from ..stack import pop, push
+
+
+def sload(evm: Evm) -> None:
+    """
+    Loads to the stack, the value corresponding to a certain key from the
+    storage of the current account.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    key = pop(evm.stack).to_be_bytes32()
+
+    # GAS
+    charge_gas(evm, GAS_SLOAD)
+
+    # OPERATION
+    value = get_storage(
+        evm.message.block_env.state, evm.message.current_target, key
+    )
+
+    push(evm.stack, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def sstore(evm: Evm) -> None:
+    """
+    Stores a value at a certain key in the current context's storage.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    key = pop(evm.stack).to_be_bytes32()
+    new_value = pop(evm.stack)
+
+    # GAS
+    state = evm.message.block_env.state
+    current_value = get_storage(state, evm.message.current_target, key)
+    if new_value != 0 and current_value == 0:
+        gas_cost = GAS_STORAGE_SET
+    else:
+        gas_cost = GAS_STORAGE_UPDATE
+
+    if new_value == 0 and current_value != 0:
+        evm.refund_counter += int(GAS_STORAGE_CLEAR_REFUND)
+
+    charge_gas(evm, gas_cost)
+
+    # OPERATION
+    set_storage(state, evm.message.current_target, key, new_value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)

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

@@ -0,0 +1,403 @@
+"""
+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_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,
+            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,
+    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,
+        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,
+            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,
+            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