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

ethereum/forks/constantinople/vm/instructions/control_flow.py

@@ -0,0 +1,171 @@
+"""
+Ethereum Virtual Machine (EVM) Control Flow Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM control flow instructions.
+"""
+
+from ethereum_types.numeric import U256, Uint
+
+from ...vm.gas import GAS_BASE, GAS_HIGH, GAS_JUMPDEST, GAS_MID, charge_gas
+from .. import Evm
+from ..exceptions import InvalidJumpDestError
+from ..stack import pop, push
+
+
+def stop(evm: Evm) -> None:
+    """
+    Stop further execution of EVM code.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    pass
+
+    # OPERATION
+    evm.running = False
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def jump(evm: Evm) -> None:
+    """
+    Alter the program counter to the location specified by the top of the
+    stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    jump_dest = Uint(pop(evm.stack))
+
+    # GAS
+    charge_gas(evm, GAS_MID)
+
+    # OPERATION
+    if jump_dest not in evm.valid_jump_destinations:
+        raise InvalidJumpDestError
+
+    # PROGRAM COUNTER
+    evm.pc = Uint(jump_dest)
+
+
+def jumpi(evm: Evm) -> None:
+    """
+    Alter the program counter to the specified location if and only if a
+    condition is true. If the condition is not true, then the program counter
+    would increase only by 1.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    jump_dest = Uint(pop(evm.stack))
+    conditional_value = pop(evm.stack)
+
+    # GAS
+    charge_gas(evm, GAS_HIGH)
+
+    # OPERATION
+    if conditional_value == 0:
+        destination = evm.pc + Uint(1)
+    elif jump_dest not in evm.valid_jump_destinations:
+        raise InvalidJumpDestError
+    else:
+        destination = jump_dest
+
+    # PROGRAM COUNTER
+    evm.pc = destination
+
+
+def pc(evm: Evm) -> None:
+    """
+    Push onto the stack the value of the program counter after reaching the
+    current instruction and without increasing it for the next instruction.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(evm.pc))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def gas_left(evm: Evm) -> None:
+    """
+    Push the amount of available gas (including the corresponding reduction
+    for the cost of this instruction) onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(evm.gas_left))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def jumpdest(evm: Evm) -> None:
+    """
+    Mark a valid destination for jumps. This is a noop, present only
+    to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is
+    valid.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_JUMPDEST)
+
+    # OPERATION
+    pass
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)

ethereum/forks/constantinople/vm/instructions/environment.py

@@ -0,0 +1,470 @@
+"""
+Ethereum Virtual Machine (EVM) Environmental Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM environment related instructions.
+"""
+
+from ethereum_types.numeric import U256, Uint, ulen
+
+from ethereum.crypto.hash import keccak256
+from ethereum.utils.numeric import ceil32
+
+from ...fork_types import EMPTY_ACCOUNT
+from ...state import get_account
+from ...utils.address import to_address_masked
+from ...vm.memory import buffer_read, memory_write
+from .. import Evm
+from ..exceptions import OutOfBoundsRead
+from ..gas import (
+    GAS_BALANCE,
+    GAS_BASE,
+    GAS_CODE_HASH,
+    GAS_COPY,
+    GAS_EXTERNAL,
+    GAS_RETURN_DATA_COPY,
+    GAS_VERY_LOW,
+    calculate_gas_extend_memory,
+    charge_gas,
+)
+from ..stack import pop, push
+
+
+def address(evm: Evm) -> None:
+    """
+    Pushes the address of the current executing account to the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256.from_be_bytes(evm.message.current_target))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def balance(evm: Evm) -> None:
+    """
+    Pushes the balance of the given account onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    address = to_address_masked(pop(evm.stack))
+
+    # GAS
+    charge_gas(evm, GAS_BALANCE)
+
+    # OPERATION
+    # Non-existent accounts default to EMPTY_ACCOUNT, which has balance 0.
+    balance = get_account(evm.message.block_env.state, address).balance
+
+    push(evm.stack, balance)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def origin(evm: Evm) -> None:
+    """
+    Pushes the address of the original transaction sender to the stack.
+    The origin address can only be an EOA.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256.from_be_bytes(evm.message.tx_env.origin))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def caller(evm: Evm) -> None:
+    """
+    Pushes the address of the caller onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256.from_be_bytes(evm.message.caller))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def callvalue(evm: Evm) -> None:
+    """
+    Push the value (in wei) sent with the call onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, evm.message.value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def calldataload(evm: Evm) -> None:
+    """
+    Push a word (32 bytes) of the input data belonging to the current
+    environment onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    start_index = pop(evm.stack)
+
+    # GAS
+    charge_gas(evm, GAS_VERY_LOW)
+
+    # OPERATION
+    value = buffer_read(evm.message.data, start_index, U256(32))
+
+    push(evm.stack, U256.from_be_bytes(value))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def calldatasize(evm: Evm) -> None:
+    """
+    Push the size of input data in current environment onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(len(evm.message.data)))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def calldatacopy(evm: Evm) -> None:
+    """
+    Copy a portion of the input data in current environment to memory.
+
+    This will also expand the memory, in case that the memory is insufficient
+    to store the data.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    memory_start_index = pop(evm.stack)
+    data_start_index = pop(evm.stack)
+    size = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(size)) // Uint(32)
+    copy_gas_cost = GAS_COPY * words
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    value = buffer_read(evm.message.data, data_start_index, size)
+    memory_write(evm.memory, memory_start_index, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def codesize(evm: Evm) -> None:
+    """
+    Push the size of code running in current environment onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(len(evm.code)))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def codecopy(evm: Evm) -> None:
+    """
+    Copy a portion of the code in current environment to memory.
+
+    This will also expand the memory, in case that the memory is insufficient
+    to store the data.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    memory_start_index = pop(evm.stack)
+    code_start_index = pop(evm.stack)
+    size = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(size)) // Uint(32)
+    copy_gas_cost = GAS_COPY * words
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    value = buffer_read(evm.code, code_start_index, size)
+    memory_write(evm.memory, memory_start_index, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def gasprice(evm: Evm) -> None:
+    """
+    Push the gas price used in current environment onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(evm.message.tx_env.gas_price))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def extcodesize(evm: Evm) -> None:
+    """
+    Push the code size of a given account onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    address = to_address_masked(pop(evm.stack))
+
+    # GAS
+    charge_gas(evm, GAS_EXTERNAL)
+
+    # OPERATION
+    code = get_account(evm.message.block_env.state, address).code
+
+    codesize = U256(len(code))
+    push(evm.stack, codesize)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def extcodecopy(evm: Evm) -> None:
+    """
+    Copy a portion of an account's code to memory.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    address = to_address_masked(pop(evm.stack))
+    memory_start_index = pop(evm.stack)
+    code_start_index = pop(evm.stack)
+    size = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(size)) // Uint(32)
+    copy_gas_cost = GAS_COPY * words
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(evm, GAS_EXTERNAL + copy_gas_cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    code = get_account(evm.message.block_env.state, address).code
+
+    value = buffer_read(code, code_start_index, size)
+    memory_write(evm.memory, memory_start_index, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def returndatasize(evm: Evm) -> None:
+    """
+    Pushes the size of the return data buffer onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(len(evm.return_data)))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def returndatacopy(evm: Evm) -> None:
+    """
+    Copies data from the return data buffer code to memory.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    memory_start_index = pop(evm.stack)
+    return_data_start_position = pop(evm.stack)
+    size = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(size)) // Uint(32)
+    copy_gas_cost = GAS_RETURN_DATA_COPY * words
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost)
+    if Uint(return_data_start_position) + Uint(size) > ulen(evm.return_data):
+        raise OutOfBoundsRead
+
+    evm.memory += b"\x00" * extend_memory.expand_by
+    value = evm.return_data[
+        return_data_start_position : return_data_start_position + size
+    ]
+    memory_write(evm.memory, memory_start_index, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def extcodehash(evm: Evm) -> None:
+    """
+    Returns the keccak256 hash of a contract’s bytecode.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    address = to_address_masked(pop(evm.stack))
+
+    # GAS
+    charge_gas(evm, GAS_CODE_HASH)
+
+    # OPERATION
+    account = get_account(evm.message.block_env.state, address)
+
+    if account == EMPTY_ACCOUNT:
+        codehash = U256(0)
+    else:
+        code = account.code
+        codehash = U256.from_be_bytes(keccak256(code))
+
+    push(evm.stack, codehash)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)

ethereum/forks/constantinople/vm/instructions/keccak.py

@@ -0,0 +1,63 @@
+"""
+Ethereum Virtual Machine (EVM) Keccak Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM keccak instructions.
+"""
+
+from ethereum_types.numeric import U256, Uint
+
+from ethereum.crypto.hash import keccak256
+from ethereum.utils.numeric import ceil32
+
+from .. import Evm
+from ..gas import (
+    GAS_KECCAK256,
+    GAS_KECCAK256_WORD,
+    calculate_gas_extend_memory,
+    charge_gas,
+)
+from ..memory import memory_read_bytes
+from ..stack import pop, push
+
+
+def keccak(evm: Evm) -> None:
+    """
+    Pushes to the stack the Keccak-256 hash of a region of memory.
+
+    This also expands the memory, in case the memory is insufficient to
+    access the data's memory location.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    memory_start_index = pop(evm.stack)
+    size = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(size)) // Uint(32)
+    word_gas_cost = GAS_KECCAK256_WORD * words
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(evm, GAS_KECCAK256 + word_gas_cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    data = memory_read_bytes(evm.memory, memory_start_index, size)
+    hashed = keccak256(data)
+
+    push(evm.stack, U256.from_be_bytes(hashed))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)