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

ethereum/forks/berlin/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

ethereum/forks/berlin/vm/precompiled_contracts/identity.py

@@ -0,0 +1,39 @@
+"""
+Ethereum Virtual Machine (EVM) IDENTITY PRECOMPILED CONTRACT.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the `IDENTITY` precompiled contract.
+"""
+
+from ethereum_types.numeric import Uint
+
+from ethereum.utils.numeric import ceil32
+
+from ...vm import Evm
+from ...vm.gas import GAS_IDENTITY, GAS_IDENTITY_WORD, charge_gas
+
+
+def identity(evm: Evm) -> None:
+    """
+    Writes the message data to output.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    word_count = ceil32(Uint(len(data))) // Uint(32)
+    charge_gas(evm, GAS_IDENTITY + GAS_IDENTITY_WORD * word_count)
+
+    # OPERATION
+    evm.output = data

ethereum/forks/berlin/vm/precompiled_contracts/mapping.py

@@ -0,0 +1,46 @@
+"""
+Precompiled Contract Addresses.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Mapping of precompiled contracts their implementations.
+"""
+
+from typing import Callable, Dict
+
+from ...fork_types import Address
+from . import (
+    ALT_BN128_ADD_ADDRESS,
+    ALT_BN128_MUL_ADDRESS,
+    ALT_BN128_PAIRING_CHECK_ADDRESS,
+    BLAKE2F_ADDRESS,
+    ECRECOVER_ADDRESS,
+    IDENTITY_ADDRESS,
+    MODEXP_ADDRESS,
+    RIPEMD160_ADDRESS,
+    SHA256_ADDRESS,
+)
+from .alt_bn128 import alt_bn128_add, alt_bn128_mul, alt_bn128_pairing_check
+from .blake2f import blake2f
+from .ecrecover import ecrecover
+from .identity import identity
+from .modexp import modexp
+from .ripemd160 import ripemd160
+from .sha256 import sha256
+
+PRE_COMPILED_CONTRACTS: Dict[Address, Callable] = {
+    ECRECOVER_ADDRESS: ecrecover,
+    SHA256_ADDRESS: sha256,
+    RIPEMD160_ADDRESS: ripemd160,
+    IDENTITY_ADDRESS: identity,
+    MODEXP_ADDRESS: modexp,
+    ALT_BN128_ADD_ADDRESS: alt_bn128_add,
+    ALT_BN128_MUL_ADDRESS: alt_bn128_mul,
+    ALT_BN128_PAIRING_CHECK_ADDRESS: alt_bn128_pairing_check,
+    BLAKE2F_ADDRESS: blake2f,
+}

ethereum/forks/berlin/vm/precompiled_contracts/modexp.py

@@ -0,0 +1,166 @@
+"""
+Ethereum Virtual Machine (EVM) MODEXP PRECOMPILED CONTRACT.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the `MODEXP` precompiled contract.
+"""
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import U256, Uint
+
+from ...vm import Evm
+from ...vm.gas import charge_gas
+from ..memory import buffer_read
+
+GQUADDIVISOR = Uint(3)
+
+
+def modexp(evm: Evm) -> None:
+    """
+    Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and.
+    `modulus`. The return value is the same length as the modulus.
+    """
+    data = evm.message.data
+
+    # GAS
+    base_length = U256.from_be_bytes(buffer_read(data, U256(0), U256(32)))
+    exp_length = U256.from_be_bytes(buffer_read(data, U256(32), U256(32)))
+    modulus_length = U256.from_be_bytes(buffer_read(data, U256(64), U256(32)))
+
+    exp_start = U256(96) + base_length
+
+    exp_head = U256.from_be_bytes(
+        buffer_read(data, exp_start, min(U256(32), exp_length))
+    )
+
+    charge_gas(
+        evm,
+        gas_cost(base_length, modulus_length, exp_length, exp_head),
+    )
+
+    # OPERATION
+    if base_length == 0 and modulus_length == 0:
+        evm.output = Bytes()
+        return
+
+    base = Uint.from_be_bytes(buffer_read(data, U256(96), base_length))
+    exp = Uint.from_be_bytes(buffer_read(data, exp_start, exp_length))
+
+    modulus_start = exp_start + exp_length
+    modulus = Uint.from_be_bytes(
+        buffer_read(data, modulus_start, modulus_length)
+    )
+
+    if modulus == 0:
+        evm.output = Bytes(b"\x00") * modulus_length
+    else:
+        evm.output = pow(base, exp, modulus).to_bytes(
+            Uint(modulus_length), "big"
+        )
+
+
+def complexity(base_length: U256, modulus_length: U256) -> Uint:
+    """
+    Estimate the complexity of performing a modular exponentiation.
+
+    Parameters
+    ----------
+    base_length :
+        Length of the array representing the base integer.
+
+    modulus_length :
+        Length of the array representing the modulus integer.
+
+    Returns
+    -------
+    complexity : `Uint`
+        Complexity of performing the operation.
+
+    """
+    max_length = max(Uint(base_length), Uint(modulus_length))
+    words = (max_length + Uint(7)) // Uint(8)
+    return words ** Uint(2)
+
+
+def iterations(exponent_length: U256, exponent_head: U256) -> Uint:
+    """
+    Calculate the number of iterations required to perform a modular
+    exponentiation.
+
+    Parameters
+    ----------
+    exponent_length :
+        Length of the array representing the exponent integer.
+
+    exponent_head :
+        First 32 bytes of the exponent (with leading zero padding if it is
+        shorter than 32 bytes), as a U256.
+
+    Returns
+    -------
+    iterations : `Uint`
+        Number of iterations.
+
+    """
+    if exponent_length <= U256(32) and exponent_head == U256(0):
+        count = Uint(0)
+    elif exponent_length <= U256(32):
+        bit_length = exponent_head.bit_length()
+
+        if bit_length > Uint(0):
+            bit_length -= Uint(1)
+
+        count = bit_length
+    else:
+        length_part = Uint(8) * (Uint(exponent_length) - Uint(32))
+        bits_part = exponent_head.bit_length()
+
+        if bits_part > Uint(0):
+            bits_part -= Uint(1)
+
+        count = length_part + bits_part
+
+    return max(count, Uint(1))
+
+
+def gas_cost(
+    base_length: U256,
+    modulus_length: U256,
+    exponent_length: U256,
+    exponent_head: U256,
+) -> Uint:
+    """
+    Calculate the gas cost of performing a modular exponentiation.
+
+    Parameters
+    ----------
+    base_length :
+        Length of the array representing the base integer.
+
+    modulus_length :
+        Length of the array representing the modulus integer.
+
+    exponent_length :
+        Length of the array representing the exponent integer.
+
+    exponent_head :
+        First 32 bytes of the exponent (with leading zero padding if it is
+        shorter than 32 bytes), as a U256.
+
+    Returns
+    -------
+    gas_cost : `Uint`
+        Gas required for performing the operation.
+
+    """
+    multiplication_complexity = complexity(base_length, modulus_length)
+    iteration_count = iterations(exponent_length, exponent_head)
+    cost = multiplication_complexity * iteration_count
+    cost //= GQUADDIVISOR
+    return max(Uint(200), cost)

ethereum/forks/berlin/vm/precompiled_contracts/ripemd160.py

@@ -0,0 +1,44 @@
+"""
+Ethereum Virtual Machine (EVM) RIPEMD160 PRECOMPILED CONTRACT.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the `RIPEMD160` precompiled contract.
+"""
+
+import hashlib
+
+from ethereum_types.numeric import Uint
+
+from ethereum.utils.byte import left_pad_zero_bytes
+from ethereum.utils.numeric import ceil32
+
+from ...vm import Evm
+from ...vm.gas import GAS_RIPEMD160, GAS_RIPEMD160_WORD, charge_gas
+
+
+def ripemd160(evm: Evm) -> None:
+    """
+    Writes the ripemd160 hash to output.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    word_count = ceil32(Uint(len(data))) // Uint(32)
+    charge_gas(evm, GAS_RIPEMD160 + GAS_RIPEMD160_WORD * word_count)
+
+    # OPERATION
+    hash_bytes = hashlib.new("ripemd160", data).digest()
+    padded_hash = left_pad_zero_bytes(hash_bytes, 32)
+    evm.output = padded_hash

ethereum/forks/berlin/vm/precompiled_contracts/sha256.py

@@ -0,0 +1,41 @@
+"""
+Ethereum Virtual Machine (EVM) SHA256 PRECOMPILED CONTRACT.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the `SHA256` precompiled contract.
+"""
+
+import hashlib
+
+from ethereum_types.numeric import Uint
+
+from ethereum.utils.numeric import ceil32
+
+from ...vm import Evm
+from ...vm.gas import GAS_SHA256, GAS_SHA256_WORD, charge_gas
+
+
+def sha256(evm: Evm) -> None:
+    """
+    Writes the sha256 hash to output.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    """
+    data = evm.message.data
+
+    # GAS
+    word_count = ceil32(Uint(len(data))) // Uint(32)
+    charge_gas(evm, GAS_SHA256 + GAS_SHA256_WORD * word_count)
+
+    # OPERATION
+    evm.output = hashlib.sha256(data).digest()

ethereum/forks/berlin/vm/runtime.py

@@ -0,0 +1,69 @@
+"""
+Ethereum Virtual Machine (EVM) Runtime Operations.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Runtime related operations used while executing EVM code.
+"""
+
+from typing import Set
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import Uint, ulen
+
+from .instructions import Ops
+
+
+def get_valid_jump_destinations(code: Bytes) -> Set[Uint]:
+    """
+    Analyze the evm code to obtain the set of valid jump destinations.
+
+    Valid jump destinations are defined as follows:
+        * The jump destination is less than the length of the code.
+        * The jump destination should have the `JUMPDEST` opcode (0x5B).
+        * The jump destination shouldn't be part of the data corresponding to
+          `PUSH-N` opcodes.
+
+    Note - Jump destinations are 0-indexed.
+
+    Parameters
+    ----------
+    code :
+        The EVM code which is to be executed.
+
+    Returns
+    -------
+    valid_jump_destinations: `Set[Uint]`
+        The set of valid jump destinations in the code.
+
+    """
+    valid_jump_destinations = set()
+    pc = Uint(0)
+
+    while pc < ulen(code):
+        try:
+            current_opcode = Ops(code[pc])
+        except ValueError:
+            # Skip invalid opcodes, as they don't affect the jumpdest
+            # analysis. Nevertheless, such invalid opcodes would be caught
+            # and raised when the interpreter runs.
+            pc += Uint(1)
+            continue
+
+        if current_opcode == Ops.JUMPDEST:
+            valid_jump_destinations.add(pc)
+        elif Ops.PUSH1.value <= current_opcode.value <= Ops.PUSH32.value:
+            # If PUSH-N opcodes are encountered, skip the current opcode along
+            # with the trailing data segment corresponding to the PUSH-N
+            # opcodes.
+            push_data_size = current_opcode.value - Ops.PUSH1.value + 1
+            pc += Uint(push_data_size)
+
+        pc += Uint(1)
+
+    return valid_jump_destinations

ethereum/forks/berlin/vm/stack.py

@@ -0,0 +1,58 @@
+"""
+Ethereum Virtual Machine (EVM) Stack.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the stack operators for the EVM.
+"""
+
+from typing import List
+
+from ethereum_types.numeric import U256
+
+from .exceptions import StackOverflowError, StackUnderflowError
+
+
+def pop(stack: List[U256]) -> U256:
+    """
+    Pops the top item off of `stack`.
+
+    Parameters
+    ----------
+    stack :
+        EVM stack.
+
+    Returns
+    -------
+    value : `U256`
+        The top element on the stack.
+
+    """
+    if len(stack) == 0:
+        raise StackUnderflowError
+
+    return stack.pop()
+
+
+def push(stack: List[U256], value: U256) -> None:
+    """
+    Pushes `value` onto `stack`.
+
+    Parameters
+    ----------
+    stack :
+        EVM stack.
+
+    value :
+        Item to be pushed onto `stack`.
+
+    """
+    if len(stack) == 1024:
+        raise StackOverflowError
+
+    return stack.append(value)

ethereum/forks/byzantium/__init__.py

@@ -0,0 +1,50 @@
+"""
+The Byzantium fork ([EIP-609]) reduces the mining rewards, delays the
+difficulty bomb, enables contracts to make non-state-changing calls to other
+contracts, and adds cryptographic primitives for layer 2 scaling.
+
+### Changes
+
+- [EIP-100: Change difficulty adjustment to target mean block time including
+  uncles][EIP-100]
+- [EIP-140: REVERT instruction in the Ethereum Virtual Machine][EIP-140]
+- [EIP-196: Precompiled contracts for addition and scalar multiplication on the
+  elliptic curve alt_bn128][EIP-196]
+- [EIP-197: Precompiled contracts for optimal ate pairing check on the elliptic
+  curve alt_bn128][EIP-197]
+- [EIP-198: Precompiled contract for bigint modular exponentiation][EIP-198]
+- [EIP-211: New opcodes: RETURNDATASIZE and RETURNDATACOPY][EIP-211]
+- [EIP-214: New opcode STATICCALL][EIP-214]
+- [EIP-649: Difficulty Bomb Delay and Block Reward Reduction][EIP-649]
+- [EIP-658: Embedding transaction status code in receipts][EIP-658]
+
+### Upgrade Schedule
+
+| Network | Block        | Expected Date    | Fork Hash    |
+| ------- | ------------ | ---------------- | ------------ |
+| Mainnet | 4,370,000    | October 16, 2017 | `0xa00bc324` |
+
+### Releases
+
+- [Harmony 2.1.0][h]
+- [Geth 1.7.2]
+- [Parity 1.7.6][p]
+
+[EIP-100]: https://eips.ethereum.org/EIPS/eip-100
+[EIP-140]: https://eips.ethereum.org/EIPS/eip-140
+[EIP-196]: https://eips.ethereum.org/EIPS/eip-196
+[EIP-197]: https://eips.ethereum.org/EIPS/eip-197
+[EIP-198]: https://eips.ethereum.org/EIPS/eip-198
+[EIP-211]: https://eips.ethereum.org/EIPS/eip-211
+[EIP-214]: https://eips.ethereum.org/EIPS/eip-214
+[EIP-609]: https://eips.ethereum.org/EIPS/eip-609
+[EIP-649]: https://eips.ethereum.org/EIPS/eip-649
+[EIP-658]: https://eips.ethereum.org/EIPS/eip-658
+[h]: https://github.com/ether-camp/ethereum-harmony/releases/tag/v2.1b56
+[Geth 1.7.2]: https://github.com/ethereum/go-ethereum/releases/tag/v1.7.2
+[p]: https://github.com/paritytech/parity/releases/tag/v1.7.6
+"""
+
+from ethereum.fork_criteria import ByBlockNumber
+
+FORK_CRITERIA = ByBlockNumber(4370000)