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

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

@@ -0,0 +1,376 @@
+"""
+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
+
+from ethereum.utils.numeric import ceil32
+
+from ...state import get_account
+from ...utils.address import to_address_masked
+from ...vm.memory import buffer_read, memory_write
+from .. import Evm
+from ..gas import (
+    GAS_BALANCE,
+    GAS_BASE,
+    GAS_COPY,
+    GAS_EXTERNAL,
+    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)

ethereum/forks/dao_fork/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)

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

@@ -0,0 +1,85 @@
+"""
+Ethereum Virtual Machine (EVM) Logging Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM logging instructions.
+"""
+
+from functools import partial
+
+from ethereum_types.numeric import Uint
+
+from ...blocks import Log
+from .. import Evm
+from ..gas import (
+    GAS_LOG,
+    GAS_LOG_DATA,
+    GAS_LOG_TOPIC,
+    calculate_gas_extend_memory,
+    charge_gas,
+)
+from ..memory import memory_read_bytes
+from ..stack import pop
+
+
+def log_n(evm: Evm, num_topics: int) -> None:
+    """
+    Appends a log entry, having `num_topics` topics, to the evm logs.
+
+    This will also expand the memory if the data (required by the log entry)
+    corresponding to the memory is not accessible.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+    num_topics :
+        The number of topics to be included in the log entry.
+
+    """
+    # STACK
+    memory_start_index = pop(evm.stack)
+    size = pop(evm.stack)
+
+    topics = []
+    for _ in range(num_topics):
+        topic = pop(evm.stack).to_be_bytes32()
+        topics.append(topic)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(memory_start_index, size)]
+    )
+    charge_gas(
+        evm,
+        GAS_LOG
+        + GAS_LOG_DATA * Uint(size)
+        + GAS_LOG_TOPIC * Uint(num_topics)
+        + extend_memory.cost,
+    )
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    log_entry = Log(
+        address=evm.message.current_target,
+        topics=tuple(topics),
+        data=memory_read_bytes(evm.memory, memory_start_index, size),
+    )
+
+    evm.logs = evm.logs + (log_entry,)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+log0 = partial(log_n, num_topics=0)
+log1 = partial(log_n, num_topics=1)
+log2 = partial(log_n, num_topics=2)
+log3 = partial(log_n, num_topics=3)
+log4 = partial(log_n, num_topics=4)

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

@@ -0,0 +1,141 @@
+"""
+Ethereum Virtual Machine (EVM) Memory Instructions.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementations of the EVM Memory instructions.
+"""
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import U256, Uint
+
+from .. import Evm
+from ..gas import (
+    GAS_BASE,
+    GAS_VERY_LOW,
+    calculate_gas_extend_memory,
+    charge_gas,
+)
+from ..memory import memory_read_bytes, memory_write
+from ..stack import pop, push
+
+
+def mstore(evm: Evm) -> None:
+    """
+    Stores a word to memory.
+    This also expands the memory, if the memory is
+    insufficient to store the word.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    start_position = pop(evm.stack)
+    value = pop(evm.stack).to_be_bytes32()
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(start_position, U256(len(value)))]
+    )
+
+    charge_gas(evm, GAS_VERY_LOW + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    memory_write(evm.memory, start_position, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def mstore8(evm: Evm) -> None:
+    """
+    Stores a byte to memory.
+    This also expands the memory, if the memory is
+    insufficient to store the word.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    start_position = pop(evm.stack)
+    value = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(start_position, U256(1))]
+    )
+
+    charge_gas(evm, GAS_VERY_LOW + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    normalized_bytes_value = Bytes([value & U256(0xFF)])
+    memory_write(evm.memory, start_position, normalized_bytes_value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def mload(evm: Evm) -> None:
+    """
+    Load word from memory.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    start_position = pop(evm.stack)
+
+    # GAS
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(start_position, U256(32))]
+    )
+    charge_gas(evm, GAS_VERY_LOW + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    value = U256.from_be_bytes(
+        memory_read_bytes(evm.memory, start_position, U256(32))
+    )
+    push(evm.stack, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def msize(evm: Evm) -> None:
+    """
+    Push the size of active memory in bytes onto the stack.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    charge_gas(evm, GAS_BASE)
+
+    # OPERATION
+    push(evm.stack, U256(len(evm.memory)))
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)