better fuzzing for modexp

contracts/utils/math/Math.sol

@@ -479,7 +479,7 @@ library Math {
 
     /**
      * @dev Returns the modular exponentiation of the specified base,
-     * exponent and modulus (b^e % m)
+     * exponent and modulus (b ** e % m)
      *
      * Requirements:
      *

scripts/generate/templates/Checkpoints.t.js

@@ -26,14 +26,14 @@ function _bound${capitalize(opts.keyTypeName)}(
     ${opts.keyTypeName} x,
     ${opts.keyTypeName} min,
     ${opts.keyTypeName} max
-) internal view returns (${opts.keyTypeName}) {
+) internal pure returns (${opts.keyTypeName}) {
     return SafeCast.to${capitalize(opts.keyTypeName)}(bound(uint256(x), uint256(min), uint256(max)));
 }
 
 function _prepareKeys(
     ${opts.keyTypeName}[] memory keys,
     ${opts.keyTypeName} maxSpread
-) internal view {
+) internal pure {
     ${opts.keyTypeName} lastKey = 0;
     for (uint256 i = 0; i < keys.length; ++i) {
         ${opts.keyTypeName} key = _bound${capitalize(opts.keyTypeName)}(keys[i], lastKey, lastKey + maxSpread);

test/utils/math/Math.t.sol

@@ -208,38 +208,36 @@ contract MathTest is Test {
 
     // MOD EXP
     function testModExp(uint256 b, uint256 e, uint256 m) public {
-        // First, let's assume m is not 0, as that will cause a division by zero error
-        vm.assume(m != 0);
-        vm.assume(e < 10);
-
-        uint256 result = Math.modExp(b, e, m);
-
-        // Next, let's check the correctness of the result
-        // The result of b^e mod m should be less than m
-        assertTrue(result < m);
-
-        if (m == 1) {
-            // If the modulo m is 1, then result will always be 0
-            assertEq(result, 0);
-        } else {
-            // The result should also satisfy the equation: result = b^e mod m
-            // Due to the large numbers involved in this calculation, we can't directly calculate b^e
-            // However, we can repeatedly multiply and reduce modulo m
+        try this.modexp(b, e, m) returns (uint256 result) {
+            assertTrue(result < m);
+            assertEq(result, _nativeModExp(b, e, m));
+        } catch {
+            assertEq(m, 0);
+        }
+    }
 
-            uint256 expected = 1;
-            for (uint i = 0; i < e; i++) {
-                expected = _mulmod(expected, b, m);
+    function _nativeModExp(uint256 b, uint256 e, uint256 m) private pure returns (uint256) {
+        uint256 r = 1 % m;
+        uint256 d = b;
+        while (e > 0) {
+            if (e % 2 > 0) {
+                r = mulmod(r, d, m);
             }
-
-            assertEq(result, expected);
+            d = mulmod(d, d, m);
+            e >>= 1;
         }
+        return r;
     }
 
     // External call
     function muldiv(uint256 x, uint256 y, uint256 d) external pure returns (uint256) {
         return Math.mulDiv(x, y, d);
     }
 
+    function modexp(uint256 a, uint256 k, uint256 n) external view returns (uint256) {
+        return Math.modExp(a, k, n);
+    }
+
     // Helpers
     function _asRounding(uint8 r) private pure returns (Math.Rounding) {
         vm.assume(r < uint8(type(Math.Rounding).max));

test/utils/structs/Checkpoints.t.sol

@@ -17,11 +17,11 @@ contract CheckpointsTrace224Test is Test {
     Checkpoints.Trace224 internal _ckpts;
 
     // helpers
-    function _boundUint32(uint32 x, uint32 min, uint32 max) internal view returns (uint32) {
+    function _boundUint32(uint32 x, uint32 min, uint32 max) internal pure returns (uint32) {
         return SafeCast.toUint32(bound(uint256(x), uint256(min), uint256(max)));
     }
 
-    function _prepareKeys(uint32[] memory keys, uint32 maxSpread) internal view {
+    function _prepareKeys(uint32[] memory keys, uint32 maxSpread) internal pure {
         uint32 lastKey = 0;
         for (uint256 i = 0; i < keys.length; ++i) {
             uint32 key = _boundUint32(keys[i], lastKey, lastKey + maxSpread);
@@ -125,11 +125,11 @@ contract CheckpointsTrace208Test is Test {
     Checkpoints.Trace208 internal _ckpts;
 
     // helpers
-    function _boundUint48(uint48 x, uint48 min, uint48 max) internal view returns (uint48) {
+    function _boundUint48(uint48 x, uint48 min, uint48 max) internal pure returns (uint48) {
         return SafeCast.toUint48(bound(uint256(x), uint256(min), uint256(max)));
     }
 
-    function _prepareKeys(uint48[] memory keys, uint48 maxSpread) internal view {
+    function _prepareKeys(uint48[] memory keys, uint48 maxSpread) internal pure {
         uint48 lastKey = 0;
         for (uint256 i = 0; i < keys.length; ++i) {
             uint48 key = _boundUint48(keys[i], lastKey, lastKey + maxSpread);
@@ -233,11 +233,11 @@ contract CheckpointsTrace160Test is Test {
     Checkpoints.Trace160 internal _ckpts;
 
     // helpers
-    function _boundUint96(uint96 x, uint96 min, uint96 max) internal view returns (uint96) {
+    function _boundUint96(uint96 x, uint96 min, uint96 max) internal pure returns (uint96) {
         return SafeCast.toUint96(bound(uint256(x), uint256(min), uint256(max)));
     }
 
-    function _prepareKeys(uint96[] memory keys, uint96 maxSpread) internal view {
+    function _prepareKeys(uint96[] memory keys, uint96 maxSpread) internal pure {
         uint96 lastKey = 0;
         for (uint256 i = 0; i < keys.length; ++i) {
             uint96 key = _boundUint96(keys[i], lastKey, lastKey + maxSpread);