chore.

Author: spencer-tb

tests/osaka/eip7883_modexp_gas_increase/conftest.py

@@ -1,6 +1,6 @@
-"""Shared pytest definitions local to EIP-7883 tests."""
+"""Shared pytest definitions for EIP-7883 tests."""
 
-from typing import Dict
+from typing import Dict, Tuple
 
 import pytest
 
@@ -9,12 +9,15 @@
     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
 
 
@@ -25,74 +28,102 @@ def env() -> Environment:
 
 
 @pytest.fixture
-def sender(pre: Alloc):
+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 gas_measure_contract(pre: Alloc):
-    """Deploys a simple contract to call ModExp and store its success."""
-    # TODO: fix the gas accounting
-    measured_code = Op.CALLDATACOPY(0, 0, Op.CALLDATASIZE) + Op.SSTORE(
-        0,
-        Op.CALL(
-            address=Spec.MODEXP_ADDRESS,
-            value=0,
-            args_offset=0,
-            args_size=Op.CALLDATASIZE,
-            ret_offset=0,
-            ret_size=0x80,
-        ),
-    )
-    return pre.deploy_contract(measured_code)
+def call_opcode() -> Op:
+    """Return default call used to call the precompile."""
+    return Op.CALL
 
 
 @pytest.fixture
-def base(base_length, request):
-    """Generate base bytes with the specified length."""
-    return b"\xff" * base_length  # arbitrary bytes
+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 modulus(modulus_length, request):
-    """Generate modulus bytes with the specified length."""
-    return b"\xff" * modulus_length  # arbitrary bytes
+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 exponent_bytes(exponent_length, exponent, request):
-    """Convert the integer exponent to bytes with the specified length."""
-    # Truncate to the lowest exponent length bytes to avoid overflow
-    mask = (1 << (8 * exponent_length)) - 1
-    truncated = exponent & mask
-    return truncated.to_bytes(exponent_length, byteorder="big")
+def precompile_gas_modifier() -> int:
+    """Modify the gas passed to the precompile, for negative testing purposes."""
+    return 0
 
 
 @pytest.fixture
-def expected_gas(
-    base: bytes,
-    exponent_bytes: bytes,
-    modulus: bytes,
-) -> int:
-    """Return expected gas consumption of the ModExp precompile."""
+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")
-    # return Spec.calculate_new_gas_cost(
-    # base_length, modulus_length, exponent_length, exponent_value
-    # )
-    # Temporarily use the old (EIP-2565) gas schedule
-    return Spec.calculate_old_gas_cost(
+    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(base: bytes, exponent_bytes: bytes, modulus: bytes) -> bytes:
-    """ModExp input data."""
-    return Spec.create_modexp_input(base, exponent_bytes, modulus)
+def modexp_input_data(input_data: bytes) -> bytes:
+    """ModExp input data, directly use the input from the test vector."""
+    return input_data
 
 
 @pytest.fixture
@@ -106,20 +137,21 @@ def tx(
         sender=sender,
         to=gas_measure_contract,
         data=modexp_input_data,
-        gas_limit=100_000,
+        gas_limit=1_000_000,
     )
 
 
 @pytest.fixture
 def post(
     gas_measure_contract: Address,
-    expected_gas: int,
+    precompile_gas: int,
 ) -> Dict[Address, Dict[str, Storage]]:
-    """Return expected post state."""
+    """Return expected post state with gas consumption check."""
     return {
         gas_measure_contract: Account(
             storage={
-                0: 1,
+                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