chore(tests): add modexp length mismatch functionality.

Author: spencer-tb

tests/byzantium/eip198_modexp_precompile/helpers.py

@@ -25,20 +25,62 @@ class ModExpInput(TestParameterGroup):
     extra_data: Bytes = Field(default_factory=Bytes)
     raw_input: Bytes | None = None
 
+    override_base_length: int | None = None
+    override_exponent_length: int | None = None
+    override_modulus_length: int | None = None
+
     @property
     def length_base(self) -> Bytes:
         """Return the length of the base."""
-        return Bytes(len(self.base).to_bytes(32, "big"))
+        length = (
+            self.override_base_length if self.override_base_length is not None else len(self.base)
+        )
+        return Bytes(length.to_bytes(32, "big"))
 
     @property
     def length_exponent(self) -> Bytes:
         """Return the length of the exponent."""
-        return Bytes(len(self.exponent).to_bytes(32, "big"))
+        length = (
+            self.override_exponent_length
+            if self.override_exponent_length is not None
+            else len(self.exponent)
+        )
+        return Bytes(length.to_bytes(32, "big"))
 
     @property
     def length_modulus(self) -> Bytes:
         """Return the length of the modulus."""
-        return Bytes(len(self.modulus).to_bytes(32, "big"))
+        length = (
+            self.override_modulus_length
+            if self.override_modulus_length is not None
+            else len(self.modulus)
+        )
+        return Bytes(length.to_bytes(32, "big"))
+
+    @property
+    def declared_base_length(self) -> int:
+        """Return the declared base length as int."""
+        return (
+            self.override_base_length if self.override_base_length is not None else len(self.base)
+        )
+
+    @property
+    def declared_exponent_length(self) -> int:
+        """Return the declared exponent length as int."""
+        return (
+            self.override_exponent_length
+            if self.override_exponent_length is not None
+            else len(self.exponent)
+        )
+
+    @property
+    def declared_modulus_length(self) -> int:
+        """Return the declared modulus length as int."""
+        return (
+            self.override_modulus_length
+            if self.override_modulus_length is not None
+            else len(self.modulus)
+        )
 
     def __bytes__(self):
         """Generate input for the MODEXP precompile."""
@@ -86,6 +128,26 @@ def from_bytes(cls, input_data: Bytes | str) -> "ModExpInput":
 
         return cls(base=base, exponent=exponent, modulus=modulus, raw_input=input_data)
 
+    @classmethod
+    def create_mismatch(
+        cls,
+        base="",
+        exponent="",
+        modulus="",
+        declared_base_length=None,
+        declared_exponent_length=None,
+        declared_modulus_length=None,
+    ):
+        """Create a ModExpInput with mismatched lengths."""
+        return cls(
+            base=Bytes(base),
+            exponent=Bytes(exponent),
+            modulus=Bytes(modulus),
+            override_base_length=declared_base_length,
+            override_exponent_length=declared_exponent_length,
+            override_modulus_length=declared_modulus_length,
+        )
+
 
 class ModExpOutput(TestParameterGroup):
     """

tests/osaka/eip7823_modexp_upper_bounds/test_modexp_upper_bounds.py

@@ -24,9 +24,9 @@ def precompile_gas(fork: Fork, mod_exp_input: ModExpInput) -> int:
     """Calculate gas cost for the ModExp precompile and verify it matches expected gas."""
     spec = Spec if fork < Osaka else Spec7883
     calculated_gas = spec.calculate_gas_cost(
-        len(mod_exp_input.base),
-        len(mod_exp_input.modulus),
-        len(mod_exp_input.exponent),
+        mod_exp_input.declared_base_length,
+        mod_exp_input.declared_modulus_length,
+        mod_exp_input.declared_exponent_length,
         mod_exp_input.exponent,
     )
     return calculated_gas
@@ -125,6 +125,13 @@ def precompile_gas(fork: Fork, mod_exp_input: ModExpInput) -> int:
             ),
             id="exp_0_base_1_mod_1025",
         ),
+        pytest.param(
+            ModExpInput.create_mismatch(
+                exponent="80",
+                declared_exponent_length=2**64,
+            ),
+            id="exp_2_pow_64_base_0_mod_0",
+        ),
     ],
 )
 def test_modexp_upper_bounds(
@@ -174,10 +181,11 @@ def test_modexp_upper_bounds(
         protected=True,
         sender=sender,
     )
+
     if (
-        len(mod_exp_input.base) <= MAX_LENGTH_BYTES
-        and len(mod_exp_input.exponent) <= MAX_LENGTH_BYTES
-        and len(mod_exp_input.modulus) <= MAX_LENGTH_BYTES
+        mod_exp_input.declared_base_length <= MAX_LENGTH_BYTES
+        and mod_exp_input.declared_exponent_length <= MAX_LENGTH_BYTES
+        and mod_exp_input.declared_modulus_length <= MAX_LENGTH_BYTES
     ) or (fork < Osaka and not expensive):
         output = ModExpOutput(call_success=True, returned_data="0x01")
     else: