feat: add eip7702, gas usage and extra edge cases

Author: LouisTsai-Csie

tests/osaka/eip7883_modexp_gas_increase/conftest.py

@@ -12,6 +12,18 @@
 from .spec import Spec, Spec7883
 
 
+@pytest.fixture
+def gas_old() -> int | None:
+    """Gas value from the test vector if any."""
+    return None
+
+
+@pytest.fixture
+def gas_new() -> int | None:
+    """Gas value from the test vector if any."""
+    return None
+
+
 @pytest.fixture
 def call_opcode() -> Op:
     """Return default call used to call the precompile."""
@@ -27,6 +39,15 @@ def call_contract_post_storage() -> Storage:
     return Storage()
 
 
+@pytest.fixture
+def call_succeeds() -> bool:
+    """
+    By default, depending on the expected output, we can deduce if the call is expected to succeed
+    or fail.
+    """
+    return True
+
+
 @pytest.fixture
 def gas_measure_contract(
     pre: Alloc,
@@ -36,6 +57,7 @@ def gas_measure_contract(
     precompile_gas: int,
     precompile_gas_modifier: int,
     call_contract_post_storage: Storage,
+    call_succeeds: bool,
 ) -> Address:
     """Deploys a contract that measures ModExp gas consumption."""
     assert call_opcode in [Op.CALL, Op.CALLCODE, Op.DELEGATECALL, Op.STATICCALL]
@@ -78,41 +100,51 @@ def gas_measure_contract(
 
     code = (
         Op.CALLDATACOPY(dest_offset=0, offset=0, size=Op.CALLDATASIZE)
-        + Op.SSTORE(call_contract_post_storage.store_next(True), call_result_measurement)
-        + Op.SSTORE(call_contract_post_storage.store_next(precompile_gas), gas_calculation)
+        + Op.SSTORE(call_contract_post_storage.store_next(call_succeeds), call_result_measurement)
         + Op.SSTORE(
             call_contract_post_storage.store_next(len(modexp_expected)),
             Op.RETURNDATASIZE(),
         )
+    )
+
+    if call_succeeds:
+        code += Op.SSTORE(call_contract_post_storage.store_next(precompile_gas), gas_calculation)
         # + Op.RETURNDATACOPY(dest_offset=0, offset=0, size=Op.RETURNDATASIZE())
         # + Op.SSTORE(call_contract_post_storage.store_next(
         #     keccak256(Bytes(vector.expected))), Op.SHA3(0, Op.RETURNDATASIZE()))
-    )
-    for i in range(len(modexp_expected) // 32):
-        code += Op.RETURNDATACOPY(0, i * 32, 32)
-        code += Op.SSTORE(
-            call_contract_post_storage.store_next(modexp_expected[i * 32 : (i + 1) * 32]),
-            Op.MLOAD(0),
-        )
+
+        for i in range(len(modexp_expected) // 32):
+            code += Op.RETURNDATACOPY(0, i * 32, 32)
+            code += Op.SSTORE(
+                call_contract_post_storage.store_next(modexp_expected[i * 32 : (i + 1) * 32]),
+                Op.MLOAD(0),
+            )
 
     return pre.deploy_contract(code)
 
 
 @pytest.fixture
-def precompile_gas(fork: Fork, modexp_input: ModExpInput, gas_old: int, gas_new: int) -> int:
+def precompile_gas(
+    fork: Fork, modexp_input: ModExpInput, gas_old: int | None, gas_new: int | None
+) -> int:
     """Calculate gas cost for the ModExp precompile and verify it matches expected gas."""
     spec = Spec if fork < Osaka else Spec7883
-    expected_gas = gas_old if fork < Osaka else gas_new
-    calculated_gas = spec.calculate_gas_cost(
-        len(modexp_input.base),
-        len(modexp_input.modulus),
-        len(modexp_input.exponent),
-        modexp_input.exponent,
-    )
-    assert calculated_gas == expected_gas, (
-        f"Calculated gas {calculated_gas} != Vector gas {expected_gas}"
-    )
-    return calculated_gas
+    try:
+        calculated_gas = spec.calculate_gas_cost(
+            len(modexp_input.base),
+            len(modexp_input.modulus),
+            len(modexp_input.exponent),
+            modexp_input.exponent,
+        )
+        if gas_old is not None and gas_new is not None:
+            expected_gas = gas_old if fork < Osaka else gas_new
+            assert calculated_gas == expected_gas, (
+                f"Calculated gas {calculated_gas} != Vector gas {expected_gas}"
+            )
+        return calculated_gas
+    except Exception as e:
+        print(f"Error calculating gas: {e}")
+        return 0
 
 
 @pytest.fixture

tests/osaka/eip7883_modexp_gas_increase/spec.py

@@ -2,6 +2,8 @@
 
 from dataclasses import dataclass
 
+from ...byzantium.eip198_modexp_precompile.helpers import ModExpInput
+
 
 @dataclass(frozen=True)
 class ReferenceSpec:
@@ -37,6 +39,17 @@ class Spec:
     EXPONENT_THRESHOLD = 32
     GAS_DIVISOR = 3
 
+    # Test Constants
+    modexp_input = ModExpInput(
+        base="e8e77626586f73b955364c7b4bbf0bb7f7685ebd40e852b164633a4acbd3244c0001020304050607",
+        exponent="01ffffff",
+        modulus="f01681d2220bfea4bb888a5543db8c0916274ddb1ea93b144c042c01d8164c950001020304050607",
+    )
+    modexp_expected = bytes.fromhex(
+        "1abce71dc2205cce4eb6934397a88136f94641342e283cbcd30e929e85605c6718ed67f475192ffd"
+    )
+    modexp_error = bytes()
+
     @classmethod
     def calculate_multiplication_complexity(cls, base_length: int, modulus_length: int) -> int:
         """Calculate the multiplication complexity of the ModExp precompile."""

tests/osaka/eip7883_modexp_gas_increase/test_modexp_thresholds.py

@@ -7,14 +7,16 @@
 
 import pytest
 
+from ethereum_test_checklists import EIPChecklist
 from ethereum_test_tools import (
     Alloc,
     StateTestFiller,
     Transaction,
 )
+from ethereum_test_tools.vm.opcode import Opcodes as Op
 
 from .helpers import vectors_from_file
-from .spec import ref_spec_7883
+from .spec import Spec, ref_spec_7883
 
 REFERENCE_SPEC_GIT_PATH = ref_spec_7883.git_path
 REFERENCE_SPEC_VERSION = ref_spec_7883.version
@@ -39,3 +41,96 @@ def test_vectors_from_file(
         tx=tx,
         post=post,
     )
+
+
+@pytest.mark.parametrize(
+    "modexp_input,modexp_expected,call_succeeds",
+    [
+        pytest.param(bytes(), bytes(), False, id="zero-length-calldata"),
+    ],
+)
+@EIPChecklist.Precompile.Test.Inputs.AllZeros
+def test_modexp_invalid(
+    state_test: StateTestFiller,
+    pre: Alloc,
+    tx: Transaction,
+    post: Dict,
+):
+    """Test ModExp gas cost using the test vectors from EIP-7883."""
+    state_test(
+        pre=pre,
+        tx=tx,
+        post=post,
+    )
+
+
+@pytest.mark.parametrize(
+    "call_opcode",
+    [
+        Op.CALL,
+        Op.STATICCALL,
+        Op.DELEGATECALL,
+        Op.CALLCODE,
+    ],
+)
+@pytest.mark.parametrize(
+    "modexp_input,modexp_expected",
+    [
+        pytest.param(Spec.modexp_input, Spec.modexp_expected, id="base-heavy"),
+    ],
+)
+@EIPChecklist.Precompile.Test.CallContexts.Static
+@EIPChecklist.Precompile.Test.CallContexts.Delegate
+@EIPChecklist.Precompile.Test.CallContexts.Callcode
+@EIPChecklist.Precompile.Test.CallContexts.Normal
+def test_modexp_call_operations(
+    state_test: StateTestFiller,
+    pre: Alloc,
+    tx: Transaction,
+    post: Dict,
+):
+    """Test ModExp call related operations with EIP-7883."""
+    state_test(
+        pre=pre,
+        tx=tx,
+        post=post,
+    )
+
+
+@pytest.mark.parametrize(
+    "modexp_input,modexp_expected,precompile_gas_modifier,call_succeeds",
+    [
+        pytest.param(
+            Spec.modexp_input,
+            Spec.modexp_expected,
+            1,
+            True,
+            id="extra_gas",
+        ),
+        pytest.param(
+            Spec.modexp_input,
+            Spec.modexp_expected,
+            0,
+            True,
+            id="exact_gas",
+        ),
+        pytest.param(
+            Spec.modexp_input,
+            Spec.modexp_error,
+            -1,
+            False,
+            id="insufficient_gas",
+        ),
+    ],
+)
+@EIPChecklist.Precompile.Test.ValueTransfer.Fee.Over
+@EIPChecklist.Precompile.Test.ValueTransfer.Fee.Exact
+@EIPChecklist.Precompile.Test.ValueTransfer.Fee.Under
+def test_modexp_gas_usage(
+    state_test: StateTestFiller,
+    pre: Alloc,
+    tx: Transaction,
+    post: Dict,
+):
+    """Test ModExp gas cost using the test vectors from EIP-7883."""
+    state_test(pre=pre, tx=tx, post=post)

tests/prague/eip7702_set_code_tx/test_set_code_txs.py

@@ -2541,7 +2541,7 @@ def test_set_code_to_log(
 
 @pytest.mark.with_all_call_opcodes
 @pytest.mark.with_all_precompiles
-@pytest.mark.eip_checklist("precompile/test/call_contexts/set_code", eips=[7951])
+@pytest.mark.eip_checklist("precompile/test/call_contexts/set_code", eips=[7951, 7883])
 def test_set_code_to_precompile(
     state_test: StateTestFiller,
     pre: Alloc,