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

ethereum/forks/byzantium/vm/interpreter.py

@@ -0,0 +1,299 @@
+"""
+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_exists_and_is_empty,
+    account_has_code_or_nonce,
+    account_has_storage,
+    begin_transaction,
+    commit_transaction,
+    destroy_storage,
+    increment_nonce,
+    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,
+    OutOfGasError,
+    Revert,
+    StackDepthLimitError,
+)
+from .instructions import Ops, op_implementation
+from .runtime import get_valid_jump_destinations
+
+STACK_DEPTH_LIMIT = Uint(1024)
+MAX_CODE_SIZE = 0x6000
+
+
+@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. `touched_accounts`: Accounts that have been touched.
+          6. `error`: The error from the execution if any.
+    """
+
+    gas_left: Uint
+    refund_counter: U256
+    logs: Tuple[Log, ...]
+    accounts_to_delete: Set[Address]
+    touched_accounts: 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(), set(), AddressCollision()
+            )
+        else:
+            evm = process_create_message(message)
+    else:
+        evm = process_message(message)
+        if account_exists_and_is_empty(
+            block_env.state, Address(message.target)
+        ):
+            evm.touched_accounts.add(Address(message.target))
+
+    if evm.error:
+        logs: Tuple[Log, ...] = ()
+        accounts_to_delete = set()
+        touched_accounts = set()
+    else:
+        logs = evm.logs
+        accounts_to_delete = evm.accounts_to_delete
+        touched_accounts = evm.touched_accounts
+        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,
+        touched_accounts=touched_accounts,
+        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.byzantium.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` happened before Spurious Dragon and left empty
+    #   code.
+    destroy_storage(state, message.current_target)
+
+    increment_nonce(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)
+            if len(contract_code) > MAX_CODE_SIZE:
+                raise OutOfGasError
+        except ExceptionalHalt as error:
+            rollback_transaction(state)
+            evm.gas_left = Uint(0)
+            evm.output = b""
+            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.byzantium.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(),
+        touched_accounts=set(),
+        return_data=b"",
+        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.output = b""
+        evm.error = error
+    except Revert as error:
+        evm_trace(evm, OpException(error))
+        evm.error = error
+    return evm

ethereum/forks/byzantium/vm/memory.py

@@ -0,0 +1,84 @@
+"""
+Ethereum Virtual Machine (EVM) Memory.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+EVM memory operations.
+"""
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import U256, Uint
+
+from ethereum.utils.byte import right_pad_zero_bytes
+
+
+def memory_write(
+    memory: bytearray, start_position: U256, value: Bytes
+) -> None:
+    """
+    Writes to memory.
+
+    Parameters
+    ----------
+    memory :
+        Memory contents of the EVM.
+    start_position :
+        Starting pointer to the memory.
+    value :
+        Data to write to memory.
+
+    """
+    memory[start_position : int(start_position) + len(value)] = value
+
+
+def memory_read_bytes(
+    memory: bytearray, start_position: U256, size: U256
+) -> Bytes:
+    """
+    Read bytes from memory.
+
+    Parameters
+    ----------
+    memory :
+        Memory contents of the EVM.
+    start_position :
+        Starting pointer to the memory.
+    size :
+        Size of the data that needs to be read from `start_position`.
+
+    Returns
+    -------
+    data_bytes :
+        Data read from memory.
+
+    """
+    return Bytes(memory[start_position : Uint(start_position) + Uint(size)])
+
+
+def buffer_read(buffer: Bytes, start_position: U256, size: U256) -> Bytes:
+    """
+    Read bytes from a buffer. Padding with zeros if necessary.
+
+    Parameters
+    ----------
+    buffer :
+        Memory contents of the EVM.
+    start_position :
+        Starting pointer to the memory.
+    size :
+        Size of the data that needs to be read from `start_position`.
+
+    Returns
+    -------
+    data_bytes :
+        Data read from memory.
+
+    """
+    return right_pad_zero_bytes(
+        buffer[start_position : Uint(start_position) + Uint(size)], size
+    )

ethereum/forks/byzantium/vm/precompiled_contracts/__init__.py

@@ -0,0 +1,36 @@
+"""
+Precompiled Contract Addresses.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Addresses of precompiled contracts and mappings to their
+implementations.
+"""
+
+from ...utils.hexadecimal import hex_to_address
+
+__all__ = (
+    "ECRECOVER_ADDRESS",
+    "SHA256_ADDRESS",
+    "RIPEMD160_ADDRESS",
+    "IDENTITY_ADDRESS",
+    "MODEXP_ADDRESS",
+    "ALT_BN128_ADD_ADDRESS",
+    "ALT_BN128_MUL_ADDRESS",
+    "ALT_BN128_PAIRING_CHECK_ADDRESS",
+    "BLAKE2F_ADDRESS",
+)
+
+ECRECOVER_ADDRESS = hex_to_address("0x01")
+SHA256_ADDRESS = hex_to_address("0x02")
+RIPEMD160_ADDRESS = hex_to_address("0x03")
+IDENTITY_ADDRESS = hex_to_address("0x04")
+MODEXP_ADDRESS = hex_to_address("0x05")
+ALT_BN128_ADD_ADDRESS = hex_to_address("0x06")
+ALT_BN128_MUL_ADDRESS = hex_to_address("0x07")
+ALT_BN128_PAIRING_CHECK_ADDRESS = hex_to_address("0x08")

ethereum/forks/byzantium/vm/precompiled_contracts/alt_bn128.py

@@ -0,0 +1,230 @@
+"""
+Ethereum Virtual Machine (EVM) ALT_BN128 CONTRACTS.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the ALT_BN128 precompiled contracts.
+"""
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import U256, Uint
+from py_ecc.optimized_bn128.optimized_curve import (
+    FQ,
+    FQ2,
+    FQ12,
+    add,
+    b,
+    b2,
+    curve_order,
+    field_modulus,
+    is_inf,
+    is_on_curve,
+    multiply,
+    normalize,
+)
+from py_ecc.optimized_bn128.optimized_pairing import pairing
+from py_ecc.typing import Optimized_Point3D as Point3D
+
+from ...vm import Evm
+from ...vm.gas import charge_gas
+from ...vm.memory import buffer_read
+from ..exceptions import InvalidParameter, OutOfGasError
+
+
+def bytes_to_g1(data: Bytes) -> Point3D[FQ]:
+    """
+    Decode 64 bytes to a point on the curve.
+
+    Parameters
+    ----------
+    data :
+        The bytes data to decode.
+
+    Returns
+    -------
+    point : Point3D
+        A point on the curve.
+
+    Raises
+    ------
+    InvalidParameter
+        Either a field element is invalid or the point is not on the curve.
+
+    """
+    if len(data) != 64:
+        raise InvalidParameter("Input should be 64 bytes long")
+
+    x_bytes = buffer_read(data, U256(0), U256(32))
+    x = int(U256.from_be_bytes(x_bytes))
+    y_bytes = buffer_read(data, U256(32), U256(32))
+    y = int(U256.from_be_bytes(y_bytes))
+
+    if x >= field_modulus:
+        raise InvalidParameter("Invalid field element")
+    if y >= field_modulus:
+        raise InvalidParameter("Invalid field element")
+
+    z = 1
+    if x == 0 and y == 0:
+        z = 0
+
+    point = (FQ(x), FQ(y), FQ(z))
+
+    # Check if the point is on the curve
+    if not is_on_curve(point, b):
+        raise InvalidParameter("Point is not on curve")
+
+    return point
+
+
+def bytes_to_g2(data: Bytes) -> Point3D[FQ2]:
+    """
+    Decode 128 bytes to a G2 point.
+
+    Parameters
+    ----------
+    data :
+        The bytes data to decode.
+
+    Returns
+    -------
+    point : Point2D
+        A point on the curve.
+
+    Raises
+    ------
+    InvalidParameter
+        Either a field element is invalid or the point is not on the curve.
+
+    """
+    if len(data) != 128:
+        raise InvalidParameter("G2 should be 128 bytes long")
+
+    x0_bytes = buffer_read(data, U256(0), U256(32))
+    x0 = int(U256.from_be_bytes(x0_bytes))
+    x1_bytes = buffer_read(data, U256(32), U256(32))
+    x1 = int(U256.from_be_bytes(x1_bytes))
+
+    y0_bytes = buffer_read(data, U256(64), U256(32))
+    y0 = int(U256.from_be_bytes(y0_bytes))
+    y1_bytes = buffer_read(data, U256(96), U256(32))
+    y1 = int(U256.from_be_bytes(y1_bytes))
+
+    if x0 >= field_modulus or x1 >= field_modulus:
+        raise InvalidParameter("Invalid field element")
+    if y0 >= field_modulus or y1 >= field_modulus:
+        raise InvalidParameter("Invalid field element")
+
+    x = FQ2((x1, x0))
+    y = FQ2((y1, y0))
+
+    z = (1, 0)
+    if x == FQ2((0, 0)) and y == FQ2((0, 0)):
+        z = (0, 0)
+
+    point = (x, y, FQ2(z))
+
+    # Check if the point is on the curve
+    if not is_on_curve(point, b2):
+        raise InvalidParameter("Point is not on curve")
+
+    return point
+
+
+def alt_bn128_add(evm: Evm) -> None:
+    """
+    The ALT_BN128 addition precompiled contract.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    charge_gas(evm, Uint(500))
+
+    # OPERATION
+    try:
+        p0 = bytes_to_g1(buffer_read(data, U256(0), U256(64)))
+        p1 = bytes_to_g1(buffer_read(data, U256(64), U256(64)))
+    except InvalidParameter as e:
+        raise OutOfGasError from e
+
+    p = add(p0, p1)
+    x, y = normalize(p)
+
+    evm.output = Uint(x).to_be_bytes32() + Uint(y).to_be_bytes32()
+
+
+def alt_bn128_mul(evm: Evm) -> None:
+    """
+    The ALT_BN128 multiplication precompiled contract.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    charge_gas(evm, Uint(40000))
+
+    # OPERATION
+    try:
+        p0 = bytes_to_g1(buffer_read(data, U256(0), U256(64)))
+    except InvalidParameter as e:
+        raise OutOfGasError from e
+    n = int(U256.from_be_bytes(buffer_read(data, U256(64), U256(32))))
+
+    p = multiply(p0, n)
+    x, y = normalize(p)
+
+    evm.output = Uint(x).to_be_bytes32() + Uint(y).to_be_bytes32()
+
+
+def alt_bn128_pairing_check(evm: Evm) -> None:
+    """
+    The ALT_BN128 pairing check precompiled contract.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    charge_gas(evm, Uint(80000 * (len(data) // 192) + 100000))
+
+    # OPERATION
+    if len(data) % 192 != 0:
+        raise OutOfGasError
+    result = FQ12.one()
+    for i in range(len(data) // 192):
+        try:
+            p = bytes_to_g1(buffer_read(data, U256(192 * i), U256(64)))
+            q = bytes_to_g2(buffer_read(data, U256(192 * i + 64), U256(128)))
+        except InvalidParameter as e:
+            raise OutOfGasError from e
+        if not is_inf(multiply(p, curve_order)):
+            raise OutOfGasError
+        if not is_inf(multiply(q, curve_order)):
+            raise OutOfGasError
+
+        result *= pairing(q, p)
+
+    if result == FQ12.one():
+        evm.output = U256(1).to_be_bytes32()
+    else:
+        evm.output = U256(0).to_be_bytes32()

ethereum/forks/byzantium/vm/precompiled_contracts/ecrecover.py

@@ -0,0 +1,64 @@
+"""
+Ethereum Virtual Machine (EVM) ECRECOVER PRECOMPILED CONTRACT.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the ECRECOVER precompiled contract.
+"""
+
+from ethereum_types.numeric import U256
+
+from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
+from ethereum.crypto.hash import Hash32, keccak256
+from ethereum.exceptions import InvalidSignatureError
+from ethereum.utils.byte import left_pad_zero_bytes
+
+from ...vm import Evm
+from ...vm.gas import GAS_ECRECOVER, charge_gas
+from ...vm.memory import buffer_read
+
+
+def ecrecover(evm: Evm) -> None:
+    """
+    Decrypts the address using elliptic curve DSA recovery mechanism and writes
+    the address to output.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    charge_gas(evm, GAS_ECRECOVER)
+
+    # OPERATION
+    message_hash_bytes = buffer_read(data, U256(0), U256(32))
+    message_hash = Hash32(message_hash_bytes)
+    v = U256.from_be_bytes(buffer_read(data, U256(32), U256(32)))
+    r = U256.from_be_bytes(buffer_read(data, U256(64), U256(32)))
+    s = U256.from_be_bytes(buffer_read(data, U256(96), U256(32)))
+
+    if v != U256(27) and v != U256(28):
+        return
+    if U256(0) >= r or r >= SECP256K1N:
+        return
+    if U256(0) >= s or s >= SECP256K1N:
+        return
+
+    try:
+        public_key = secp256k1_recover(r, s, v - U256(27), message_hash)
+    except InvalidSignatureError:
+        # unable to extract public key
+        return
+
+    address = keccak256(public_key)[12:32]
+    padded_address = left_pad_zero_bytes(address, 32)
+    evm.output = padded_address