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

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

@@ -0,0 +1,88 @@
+"""
+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 ..exceptions import WriteInStaticContext
+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
+    if evm.message.is_static:
+        raise WriteInStaticContext
+    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/cancun/vm/instructions/memory.py

@@ -0,0 +1,177 @@
+"""
+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 ethereum.utils.numeric import ceil32
+
+from .. import Evm
+from ..gas import (
+    GAS_BASE,
+    GAS_COPY,
+    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)
+
+
+def mcopy(evm: Evm) -> None:
+    """
+    Copy the bytes in memory from one location to another.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    destination = pop(evm.stack)
+    source = pop(evm.stack)
+    length = pop(evm.stack)
+
+    # GAS
+    words = ceil32(Uint(length)) // Uint(32)
+    copy_gas_cost = GAS_COPY * words
+
+    extend_memory = calculate_gas_extend_memory(
+        evm.memory, [(source, length), (destination, length)]
+    )
+    charge_gas(evm, GAS_VERY_LOW + copy_gas_cost + extend_memory.cost)
+
+    # OPERATION
+    evm.memory += b"\x00" * extend_memory.expand_by
+    value = memory_read_bytes(evm.memory, source, length)
+    memory_write(evm.memory, destination, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)

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

@@ -0,0 +1,208 @@
+"""
+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. Push zero if num_bytes is zero.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    num_bytes :
+        The number of immediate bytes to be read from the code and pushed to
+        the stack. Push zero if num_bytes is zero.
+
+    """
+    # STACK
+    pass
+
+    # GAS
+    if num_bytes == 0:
+        charge_gas(evm, GAS_BASE)
+    else:
+        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)
+
+
+push0 = partial(push_n, num_bytes=0)
+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/cancun/vm/instructions/storage.py

@@ -0,0 +1,188 @@
+"""
+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,
+    get_storage_original,
+    get_transient_storage,
+    set_storage,
+    set_transient_storage,
+)
+from .. import Evm
+from ..exceptions import OutOfGasError, WriteInStaticContext
+from ..gas import (
+    GAS_CALL_STIPEND,
+    GAS_COLD_SLOAD,
+    GAS_STORAGE_CLEAR_REFUND,
+    GAS_STORAGE_SET,
+    GAS_STORAGE_UPDATE,
+    GAS_WARM_ACCESS,
+    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
+    if (evm.message.current_target, key) in evm.accessed_storage_keys:
+        charge_gas(evm, GAS_WARM_ACCESS)
+    else:
+        evm.accessed_storage_keys.add((evm.message.current_target, key))
+        charge_gas(evm, GAS_COLD_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)
+    if evm.gas_left <= GAS_CALL_STIPEND:
+        raise OutOfGasError
+
+    state = evm.message.block_env.state
+    original_value = get_storage_original(
+        state, evm.message.current_target, key
+    )
+    current_value = get_storage(state, evm.message.current_target, key)
+
+    gas_cost = Uint(0)
+
+    if (evm.message.current_target, key) not in evm.accessed_storage_keys:
+        evm.accessed_storage_keys.add((evm.message.current_target, key))
+        gas_cost += GAS_COLD_SLOAD
+
+    if original_value == current_value and current_value != new_value:
+        if original_value == 0:
+            gas_cost += GAS_STORAGE_SET
+        else:
+            gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD
+    else:
+        gas_cost += GAS_WARM_ACCESS
+
+    # Refund Counter Calculation
+    if current_value != new_value:
+        if original_value != 0 and current_value != 0 and new_value == 0:
+            # Storage is cleared for the first time in the transaction
+            evm.refund_counter += int(GAS_STORAGE_CLEAR_REFUND)
+
+        if original_value != 0 and current_value == 0:
+            # Gas refund issued earlier to be reversed
+            evm.refund_counter -= int(GAS_STORAGE_CLEAR_REFUND)
+
+        if original_value == new_value:
+            # Storage slot being restored to its original value
+            if original_value == 0:
+                # Slot was originally empty and was SET earlier
+                evm.refund_counter += int(GAS_STORAGE_SET - GAS_WARM_ACCESS)
+            else:
+                # Slot was originally non-empty and was UPDATED earlier
+                evm.refund_counter += int(
+                    GAS_STORAGE_UPDATE - GAS_COLD_SLOAD - GAS_WARM_ACCESS
+                )
+
+    charge_gas(evm, gas_cost)
+    if evm.message.is_static:
+        raise WriteInStaticContext
+    set_storage(state, evm.message.current_target, key, new_value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def tload(evm: Evm) -> None:
+    """
+    Loads to the stack, the value corresponding to a certain key from the
+    transient storage of the current account.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    key = pop(evm.stack).to_be_bytes32()
+
+    # GAS
+    charge_gas(evm, GAS_WARM_ACCESS)
+
+    # OPERATION
+    value = get_transient_storage(
+        evm.message.tx_env.transient_storage, evm.message.current_target, key
+    )
+    push(evm.stack, value)
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)
+
+
+def tstore(evm: Evm) -> None:
+    """
+    Stores a value at a certain key in the current context's transient storage.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    # STACK
+    key = pop(evm.stack).to_be_bytes32()
+    new_value = pop(evm.stack)
+
+    # GAS
+    charge_gas(evm, GAS_WARM_ACCESS)
+    if evm.message.is_static:
+        raise WriteInStaticContext
+    set_transient_storage(
+        evm.message.tx_env.transient_storage,
+        evm.message.current_target,
+        key,
+        new_value,
+    )
+
+    # PROGRAM COUNTER
+    evm.pc += Uint(1)