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

ethereum/forks/prague/vm/precompiled_contracts/bls12_381/bls12_381_g1.py

@@ -0,0 +1,151 @@
+"""
+Ethereum Virtual Machine (EVM) BLS12 381 CONTRACTS.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of pre-compiles in G1 (curve over base prime field).
+"""
+
+from ethereum_types.numeric import U256, Uint
+from py_ecc.bls.hash_to_curve import clear_cofactor_G1, map_to_curve_G1
+from py_ecc.optimized_bls12_381.optimized_curve import FQ
+from py_ecc.optimized_bls12_381.optimized_curve import add as bls12_add
+from py_ecc.optimized_bls12_381.optimized_curve import (
+    multiply as bls12_multiply,
+)
+
+from ....vm import Evm
+from ....vm.gas import (
+    GAS_BLS_G1_ADD,
+    GAS_BLS_G1_MAP,
+    GAS_BLS_G1_MUL,
+    charge_gas,
+)
+from ....vm.memory import buffer_read
+from ...exceptions import InvalidParameter
+from . import (
+    G1_K_DISCOUNT,
+    G1_MAX_DISCOUNT,
+    MULTIPLIER,
+    bytes_to_g1,
+    decode_g1_scalar_pair,
+    g1_to_bytes,
+)
+
+LENGTH_PER_PAIR = 160
+
+
+def bls12_g1_add(evm: Evm) -> None:
+    """
+    The bls12_381 G1 point addition precompile.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) != 256:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    charge_gas(evm, Uint(GAS_BLS_G1_ADD))
+
+    # OPERATION
+    p1 = bytes_to_g1(buffer_read(data, U256(0), U256(128)))
+    p2 = bytes_to_g1(buffer_read(data, U256(128), U256(128)))
+
+    result = bls12_add(p1, p2)
+
+    evm.output = g1_to_bytes(result)
+
+
+def bls12_g1_msm(evm: Evm) -> None:
+    """
+    The bls12_381 G1 multi-scalar multiplication precompile.
+    Note: This uses the naive approach to multi-scalar multiplication
+    which is not suitably optimized for production clients. Clients are
+    required to implement a more efficient algorithm such as the Pippenger
+    algorithm.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) == 0 or len(data) % LENGTH_PER_PAIR != 0:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    k = len(data) // LENGTH_PER_PAIR
+    if k <= 128:
+        discount = Uint(G1_K_DISCOUNT[k - 1])
+    else:
+        discount = Uint(G1_MAX_DISCOUNT)
+
+    gas_cost = Uint(k) * GAS_BLS_G1_MUL * discount // MULTIPLIER
+    charge_gas(evm, gas_cost)
+
+    # OPERATION
+    for i in range(k):
+        start_index = i * LENGTH_PER_PAIR
+        end_index = start_index + LENGTH_PER_PAIR
+
+        p, m = decode_g1_scalar_pair(data[start_index:end_index])
+        product = bls12_multiply(p, m)
+
+        if i == 0:
+            result = product
+        else:
+            result = bls12_add(result, product)
+
+    evm.output = g1_to_bytes(result)
+
+
+def bls12_map_fp_to_g1(evm: Evm) -> None:
+    """
+    Precompile to map field element to G1.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) != 64:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    charge_gas(evm, Uint(GAS_BLS_G1_MAP))
+
+    # OPERATION
+    fp = int.from_bytes(data, "big")
+    if fp >= FQ.field_modulus:
+        raise InvalidParameter("coordinate >= field modulus")
+
+    g1_optimized_3d = clear_cofactor_G1(map_to_curve_G1(FQ(fp)))
+    evm.output = g1_to_bytes(g1_optimized_3d)

ethereum/forks/prague/vm/precompiled_contracts/bls12_381/bls12_381_g2.py

@@ -0,0 +1,153 @@
+"""
+Ethereum Virtual Machine (EVM) BLS12 381 G2 CONTRACTS.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of pre-compiles in G2 (curve over base prime field).
+"""
+
+from ethereum_types.numeric import U256, Uint
+from py_ecc.bls.hash_to_curve import clear_cofactor_G2, map_to_curve_G2
+from py_ecc.optimized_bls12_381.optimized_curve import FQ2
+from py_ecc.optimized_bls12_381.optimized_curve import add as bls12_add
+from py_ecc.optimized_bls12_381.optimized_curve import (
+    multiply as bls12_multiply,
+)
+
+from ....vm import Evm
+from ....vm.gas import (
+    GAS_BLS_G2_ADD,
+    GAS_BLS_G2_MAP,
+    GAS_BLS_G2_MUL,
+    charge_gas,
+)
+from ....vm.memory import buffer_read
+from ...exceptions import InvalidParameter
+from . import (
+    G2_K_DISCOUNT,
+    G2_MAX_DISCOUNT,
+    MULTIPLIER,
+    bytes_to_fq2,
+    bytes_to_g2,
+    decode_g2_scalar_pair,
+    g2_to_bytes,
+)
+
+LENGTH_PER_PAIR = 288
+
+
+def bls12_g2_add(evm: Evm) -> None:
+    """
+    The bls12_381 G2 point addition precompile.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) != 512:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    charge_gas(evm, Uint(GAS_BLS_G2_ADD))
+
+    # OPERATION
+    p1 = bytes_to_g2(buffer_read(data, U256(0), U256(256)))
+    p2 = bytes_to_g2(buffer_read(data, U256(256), U256(256)))
+
+    result = bls12_add(p1, p2)
+
+    evm.output = g2_to_bytes(result)
+
+
+def bls12_g2_msm(evm: Evm) -> None:
+    """
+    The bls12_381 G2 multi-scalar multiplication precompile.
+    Note: This uses the naive approach to multi-scalar multiplication
+    which is not suitably optimized for production clients. Clients are
+    required to implement a more efficient algorithm such as the Pippenger
+    algorithm.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) == 0 or len(data) % LENGTH_PER_PAIR != 0:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    k = len(data) // LENGTH_PER_PAIR
+    if k <= 128:
+        discount = Uint(G2_K_DISCOUNT[k - 1])
+    else:
+        discount = Uint(G2_MAX_DISCOUNT)
+
+    gas_cost = Uint(k) * GAS_BLS_G2_MUL * discount // MULTIPLIER
+    charge_gas(evm, gas_cost)
+
+    # OPERATION
+    for i in range(k):
+        start_index = i * LENGTH_PER_PAIR
+        end_index = start_index + LENGTH_PER_PAIR
+
+        p, m = decode_g2_scalar_pair(data[start_index:end_index])
+        product = bls12_multiply(p, m)
+
+        if i == 0:
+            result = product
+        else:
+            result = bls12_add(result, product)
+
+    evm.output = g2_to_bytes(result)
+
+
+def bls12_map_fp2_to_g2(evm: Evm) -> None:
+    """
+    Precompile to map field element to G2.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid.
+
+    """
+    data = evm.message.data
+    if len(data) != 128:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    charge_gas(evm, Uint(GAS_BLS_G2_MAP))
+
+    # OPERATION
+    field_element = bytes_to_fq2(data)
+    assert isinstance(field_element, FQ2)
+
+    fp2 = bytes_to_fq2(data)
+    g2_3d = clear_cofactor_G2(map_to_curve_G2(fp2))
+
+    evm.output = g2_to_bytes(g2_3d)

ethereum/forks/prague/vm/precompiled_contracts/bls12_381/bls12_381_pairing.py

@@ -0,0 +1,69 @@
+"""
+Ethereum Virtual Machine (EVM) BLS12 381 PAIRING PRE-COMPILE.
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the BLS12 381 pairing pre-compile.
+"""
+
+from ethereum_types.numeric import Uint
+from py_ecc.optimized_bls12_381 import FQ12, curve_order, is_inf, pairing
+from py_ecc.optimized_bls12_381 import multiply as bls12_multiply
+
+from ....vm import Evm
+from ....vm.gas import charge_gas
+from ...exceptions import InvalidParameter
+from . import bytes_to_g1, bytes_to_g2
+
+
+def bls12_pairing(evm: Evm) -> None:
+    """
+    The bls12_381 pairing precompile.
+
+    Parameters
+    ----------
+    evm :
+        The current EVM frame.
+
+    Raises
+    ------
+    InvalidParameter
+        If the input length is invalid or if sub-group check fails.
+
+    """
+    data = evm.message.data
+    if len(data) == 0 or len(data) % 384 != 0:
+        raise InvalidParameter("Invalid Input Length")
+
+    # GAS
+    k = len(data) // 384
+    gas_cost = Uint(32600 * k + 37700)
+    charge_gas(evm, gas_cost)
+
+    # OPERATION
+    result = FQ12.one()
+    for i in range(k):
+        g1_start = Uint(384 * i)
+        g2_start = Uint(384 * i + 128)
+
+        g1_slice = data[g1_start : g1_start + Uint(128)]
+        g1_point = bytes_to_g1(bytes(g1_slice))
+        if not is_inf(bls12_multiply(g1_point, curve_order)):
+            raise InvalidParameter("Sub-group check failed for G1 point.")
+
+        g2_slice = data[g2_start : g2_start + Uint(256)]
+        g2_point = bytes_to_g2(bytes(g2_slice))
+        if not is_inf(bls12_multiply(g2_point, curve_order)):
+            raise InvalidParameter("Sub-group check failed for G2 point.")
+
+        result *= pairing(g2_point, g1_point)
+
+    if result == FQ12.one():
+        evm.output = b"\x00" * 31 + b"\x01"
+    else:
+        evm.output = b"\x00" * 32

ethereum/forks/prague/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/prague/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/prague/vm/precompiled_contracts/mapping.py

@@ -0,0 +1,74 @@
+"""
+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,
+    BLS12_G1_ADD_ADDRESS,
+    BLS12_G1_MSM_ADDRESS,
+    BLS12_G2_ADD_ADDRESS,
+    BLS12_G2_MSM_ADDRESS,
+    BLS12_MAP_FP2_TO_G2_ADDRESS,
+    BLS12_MAP_FP_TO_G1_ADDRESS,
+    BLS12_PAIRING_ADDRESS,
+    ECRECOVER_ADDRESS,
+    IDENTITY_ADDRESS,
+    MODEXP_ADDRESS,
+    POINT_EVALUATION_ADDRESS,
+    RIPEMD160_ADDRESS,
+    SHA256_ADDRESS,
+)
+from .alt_bn128 import alt_bn128_add, alt_bn128_mul, alt_bn128_pairing_check
+from .blake2f import blake2f
+from .bls12_381.bls12_381_g1 import (
+    bls12_g1_add,
+    bls12_g1_msm,
+    bls12_map_fp_to_g1,
+)
+from .bls12_381.bls12_381_g2 import (
+    bls12_g2_add,
+    bls12_g2_msm,
+    bls12_map_fp2_to_g2,
+)
+from .bls12_381.bls12_381_pairing import bls12_pairing
+from .ecrecover import ecrecover
+from .identity import identity
+from .modexp import modexp
+from .point_evaluation import point_evaluation
+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,
+    POINT_EVALUATION_ADDRESS: point_evaluation,
+    BLS12_G1_ADD_ADDRESS: bls12_g1_add,
+    BLS12_G1_MSM_ADDRESS: bls12_g1_msm,
+    BLS12_G2_ADD_ADDRESS: bls12_g2_add,
+    BLS12_G2_MSM_ADDRESS: bls12_g2_msm,
+    BLS12_PAIRING_ADDRESS: bls12_pairing,
+    BLS12_MAP_FP_TO_G1_ADDRESS: bls12_map_fp_to_g1,
+    BLS12_MAP_FP2_TO_G2_ADDRESS: bls12_map_fp2_to_g2,
+}

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