feat(tests): start basic eip-7883 cases.

Author: spencer-tb

eels_resolutions.json

@@ -35,8 +35,13 @@
         "same_as": "EELSMaster"
     },
     "Prague": {
-      "git_url": "https://github.com/marioevz/execution-specs.git",
-      "branch": "forks/prague",
-      "commit": "bb0eb750d643ced0ebf5dec732cdd23558d0b7f2"
+        "git_url": "https://github.com/marioevz/execution-specs.git",
+        "branch": "forks/prague",
+        "commit": "bb0eb750d643ced0ebf5dec732cdd23558d0b7f2"
+    },
+    "Osaka": {
+        "git_url": "https://github.com/spencer-tb/execution-specs.git",
+        "branch": "forks/osaka",
+        "commit": "e59c6e3eaed0dbbca639b6f5b6acaa832e51ca00"
     }
 }

tests/osaka/eip7883_modexp_gas_increase/__init__.py

@@ -0,0 +1,6 @@
+"""
+abstract: Tests [EIP-7883: ModExp Gas Cost Increase](https://eips.ethereum.org/EIPS/eip-7883)
+    Test cases for [EIP-7883: ModExp Gas Cost Increase](https://eips.ethereum.org/EIPS/eip-7883).
+"""
+
+MODEXP_GAS_INCREASE_FORK_NAME = "Osaka"

tests/osaka/eip7883_modexp_gas_increase/conftest.py

@@ -0,0 +1,157 @@
+"""Shared pytest definitions for EIP-7883 tests."""
+
+from typing import Dict, Tuple
+
+import pytest
+
+from ethereum_test_tools import (
+    EOA,
+    Account,
+    Address,
+    Alloc,
+    Bytecode,
+    CodeGasMeasure,
+    Environment,
+    Storage,
+    Transaction,
+)
+from ethereum_test_tools.vm.opcode import Opcodes as Op
+
+from .helpers import parse_modexp_input
+from .spec import Spec
+
+
+@pytest.fixture
+def env() -> Environment:
+    """Environment fixture."""
+    return Environment()
+
+
+@pytest.fixture
+def parsed_input(input_data: bytes) -> Tuple[bytes, bytes, bytes, int]:
+    """Parse the ModExp input data."""
+    return parse_modexp_input(input_data)
+
+
+@pytest.fixture
+def base(parsed_input: Tuple[bytes, bytes, bytes, int]) -> bytes:
+    """Get the base value from the parsed input."""
+    return parsed_input[0]
+
+
+@pytest.fixture
+def exponent_bytes(parsed_input: Tuple[bytes, bytes, bytes, int]) -> bytes:
+    """Get the exponent bytes from the parsed input."""
+    return parsed_input[1]
+
+
+@pytest.fixture
+def modulus(parsed_input: Tuple[bytes, bytes, bytes, int]) -> bytes:
+    """Get the modulus value from the parsed input."""
+    return parsed_input[2]
+
+
+@pytest.fixture
+def exponent(parsed_input: Tuple[bytes, bytes, bytes, int]) -> int:
+    """Get the exponent value from the parsed input."""
+    return parsed_input[3]
+
+
+@pytest.fixture
+def sender(pre: Alloc) -> EOA:
+    """Create and fund an EOA to be used as the transaction sender."""
+    return pre.fund_eoa()
+
+
+@pytest.fixture
+def call_opcode() -> Op:
+    """Return default call used to call the precompile."""
+    return Op.CALL
+
+
+@pytest.fixture
+def modexp_call_code(call_opcode: Op, input_data: bytes) -> Bytecode:
+    """Create bytecode to call the ModExp precompile."""
+    call_code = call_opcode(
+        address=Spec.MODEXP_ADDRESS,
+        value=0,
+        args_offset=0,
+        args_size=Op.CALLDATASIZE,
+        ret_offset=0,
+        ret_size=0x80,
+    )
+    call_code += Op.SSTORE(0, Op.ISZERO(Op.ISZERO))
+    return call_code
+
+
+@pytest.fixture
+def gas_measure_contract(pre: Alloc, modexp_call_code: Bytecode) -> Address:
+    """Deploys a contract that measures ModExp gas consumption."""
+    calldata_copy = Op.CALLDATACOPY(0, 0, Op.CALLDATASIZE)
+    measured_code = CodeGasMeasure(
+        code=calldata_copy + modexp_call_code,
+        overhead_cost=12,  # TODO: Calculate overhead cost
+        extra_stack_items=0,
+        sstore_key=1,
+        stop=True,
+    )
+    return pre.deploy_contract(measured_code)
+
+
+@pytest.fixture
+def precompile_gas_modifier() -> int:
+    """Modify the gas passed to the precompile, for negative testing purposes."""
+    return 0
+
+
+@pytest.fixture
+def precompile_gas(base: bytes, exponent_bytes: bytes, modulus: bytes, expected_gas: int) -> int:
+    """Calculate gas cost for the ModExp precompile and verify it matches expected gas."""
+    base_length = len(base)
+    exponent_length = len(exponent_bytes)
+    modulus_length = len(modulus)
+    exponent_value = int.from_bytes(exponent_bytes, byteorder="big")
+    calculated_gas = Spec.calculate_new_gas_cost(
+        base_length, modulus_length, exponent_length, exponent_value
+    )
+    assert (
+        calculated_gas == expected_gas
+    ), f"Calculated gas {calculated_gas} != Vector gas {expected_gas}"
+    return calculated_gas
+
+
+@pytest.fixture
+def modexp_input_data(input_data: bytes) -> bytes:
+    """ModExp input data, directly use the input from the test vector."""
+    return input_data
+
+
+@pytest.fixture
+def tx(
+    sender: EOA,
+    gas_measure_contract: Address,
+    modexp_input_data: bytes,
+) -> Transaction:
+    """Transaction to measure gas consumption of the ModExp precompile."""
+    return Transaction(
+        sender=sender,
+        to=gas_measure_contract,
+        data=modexp_input_data,
+        gas_limit=1_000_000,
+    )
+
+
+@pytest.fixture
+def post(
+    gas_measure_contract: Address,
+    precompile_gas: int,
+) -> Dict[Address, Dict[str, Storage]]:
+    """Return expected post state with gas consumption check."""
+    return {
+        gas_measure_contract: Account(
+            storage={
+                0: 1,  # Call should succeed
+                1: precompile_gas,
+            }
+        )
+    }

tests/osaka/eip7883_modexp_gas_increase/helpers.py

@@ -0,0 +1,52 @@
+"""Helper functions for the EIP-7883 ModExp gas cost increase tests."""
+
+import json
+import os
+from typing import List, Tuple
+
+import pytest
+
+
+def current_python_script_directory(*args: str) -> str:
+    """Get the current Python script directory."""
+    return os.path.join(os.path.dirname(os.path.realpath(__file__)), *args)
+
+
+def vectors_from_file(filename: str) -> List[Tuple]:
+    """Load test vectors from a file."""
+    with open(current_python_script_directory(filename), "r") as f:
+        vectors_json = json.load(f)
+        result = []
+        for vector in vectors_json:
+            input_hex = vector["Input"]
+            name = vector["Name"]
+            gas_new = vector["GasNew"]
+            param = pytest.param(
+                bytes.fromhex(input_hex),
+                gas_new,
+                id=name,
+            )
+            result.append(param)
+        return result
+
+
+def parse_modexp_input(input_data: bytes) -> Tuple[bytes, bytes, bytes, int]:
+    """Parse ModExp input data into base, exponent bytes, modulus, and exponent value."""
+    base_length = int.from_bytes(input_data[0:32], byteorder="big")
+    exponent_length = int.from_bytes(input_data[32:64], byteorder="big")
+    modulus_length = int.from_bytes(input_data[64:96], byteorder="big")
+
+    base_start = 96
+    base_end = base_start + base_length
+    base = input_data[base_start:base_end]
+
+    exponent_start = base_end
+    exponent_end = exponent_start + exponent_length
+    exponent_bytes = input_data[exponent_start:exponent_end]
+    exponent_value = int.from_bytes(exponent_bytes, byteorder="big")
+
+    modulus_start = exponent_end
+    modulus_end = modulus_start + modulus_length
+    modulus = input_data[modulus_start:modulus_end]
+
+    return base, exponent_bytes, modulus, exponent_value

tests/osaka/eip7883_modexp_gas_increase/spec.py

@@ -0,0 +1,55 @@
+"""Defines EIP-7883 specification constants and functions."""
+
+import math
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ReferenceSpec:
+    """Defines the reference spec version and git path."""
+
+    git_path: str
+    version: str
+
+
+ref_spec_7883 = ReferenceSpec("EIPS/eip-7883.md", "13aa65810336d4f243d4563a828d5afe36035d23")
+
+
+@dataclass(frozen=True)
+class Spec:
+    """Constants and helpers for the ModExp gas cost increase EIP."""
+
+    MODEXP_ADDRESS = 0x05
+    OLD_MIN_GAS = 200
+    OLD_EXPONENT_BYTE_MULTIPLIER = 8
+    NEW_MIN_GAS = 500
+    NEW_EXPONENT_BYTE_MULTIPLIER = 16
+    NEW_LARGE_BASE_MODULUS_MULTIPLIER = 2
+    WORD_SIZE = 8
+    BASE_MODULUS_THRESHOLD = 32
+    EXPONENT_THRESHOLD = 32
+    GAS_DIVISOR = 3
+
+    @staticmethod
+    def calculate_new_gas_cost(
+        base_length: int, modulus_length: int, exponent_length: int, exponent: int
+    ) -> int:
+        """Calculate the ModExp gas cost according to EIP-7883 specification."""
+        max_length = max(base_length, modulus_length)
+        words = math.ceil(max_length / Spec.WORD_SIZE)
+        if max_length <= Spec.BASE_MODULUS_THRESHOLD:
+            multiplication_complexity = words**2
+        else:
+            multiplication_complexity = 2 * words**2
+        if exponent_length <= Spec.EXPONENT_THRESHOLD:
+            if exponent == 0:
+                iteration_count = 0
+            else:
+                iteration_count = exponent.bit_length() - 1
+        else:
+            high_bytes = exponent_length - Spec.EXPONENT_THRESHOLD
+            low_bits = (exponent & (2**256 - 1)).bit_length() - 1
+            iteration_count = (Spec.NEW_EXPONENT_BYTE_MULTIPLIER * high_bytes) + low_bits
+        iteration_count = max(iteration_count, 1)
+        gas_cost = (multiplication_complexity * iteration_count) // Spec.GAS_DIVISOR
+        return max(Spec.NEW_MIN_GAS, gas_cost)

tests/osaka/eip7883_modexp_gas_increase/test_modexp_thresholds.py

@@ -0,0 +1,42 @@
+"""
+abstract: Tests [EIP-7883: ModExp Gas Cost Increase](https://eips.ethereum.org/EIPS/eip-7883)
+    Test cases for [EIP-7883: ModExp Gas Cost Increase](https://eips.ethereum.org/EIPS/eip-7883).
+"""
+
+from typing import Dict
+
+import pytest
+
+from ethereum_test_tools import (
+    Alloc,
+    Environment,
+    StateTestFiller,
+    Transaction,
+)
+
+from . import MODEXP_GAS_INCREASE_FORK_NAME
+from .helpers import vectors_from_file
+from .spec import ref_spec_7883
+
+REFERENCE_SPEC_GIT_PATH = ref_spec_7883.git_path
+REFERENCE_SPEC_VERSION = ref_spec_7883.version
+
+pytestmark = pytest.mark.valid_from(MODEXP_GAS_INCREASE_FORK_NAME)
+
+
+@pytest.mark.parametrize("input_data,expected_gas", vectors_from_file("vectors.json"))
+def test_vectors_from_file(
+    expected_gas: int,
+    state_test: StateTestFiller,
+    env: Environment,
+    pre: Alloc,
+    tx: Transaction,
+    post: Dict,
+):
+    """Test ModExp gas cost using the test vectors from EIP-7883."""
+    state_test(
+        env=env,
+        pre=pre,
+        tx=tx,
+        post=post,
+    )