fallback to revert

contracts/utils/math/Math.sol

@@ -11,6 +11,14 @@ library Math {
      * @dev Muldiv operation overflow.
      */
     error MathOverflowedMulDiv();
+    /**
+     * @dev Modulus zero in Mod Exp operation.
+     */
+    error MathModulusEqualsZero();
+    /**
+     * @dev Static call to Mod Exp precompile fails.
+     */
+    error MathModExpCannotBeCalculated();
 
     enum Rounding {
         Floor, // Toward negative infinity
@@ -276,14 +284,21 @@ library Math {
     }
 
     /**
-     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
+     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
      *
-     * If the modulus is 0 or if the EIP-198 precompile reverts, return 0 (which is obviously an invalid result).
+     * Requirements:
+     * - modulus can't be zero
+     * - result should be obtained successfully
      */
     function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
-        if (m == 0) return 0;
+        if (m == 0) {
+            revert MathModulusEqualsZero();
+        }
         (bool success, bytes memory result) = (address(5).staticcall(abi.encode(32, 32, 32, b, e, m)));
-        return success ? abi.decode(result, (uint256)) : 0;
+        if (!success) {
+            revert MathModExpCannotBeCalculated();
+        }
+        return abi.decode(result, (uint256));
     }
 
     /**

test/utils/math/Math.t.sol

@@ -208,15 +208,11 @@ contract MathTest is Test {
 
     // MOD EXP
     function testModExp(uint256 b, uint256 e, uint256 m) public {
-        uint256 result = Math.modExp(b, e, m);
-
-        if (m == 0) {
-            // 0 means error
-            assertEq(result, 0);
-        } else {
-            // Result should be less than m, and should match the native implementation
+        try this.modexp(b, e, m) returns (uint256 result) {
             assertTrue(result < m);
             assertEq(result, _nativeModExp(b, e, m));
+        } catch {
+            assertEq(m, 0);
         }
     }
 
@@ -238,6 +234,10 @@ contract MathTest is Test {
         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/math/Math.test.js

@@ -345,12 +345,15 @@ describe('Math', function () {
       expect(await this.mock.$modExp(base, exponent, modulus)).to.equal(base ** exponent % modulus);
     });
 
-    it('returns zero when modulus is zero', async function () {
+    it('is correctly reverting when modulus is zero', async function () {
       const base = 3n;
       const exponent = 200n;
       const modulus = 0n;
 
-      expect(await this.mock.$modExp(base, exponent, modulus)).to.equal(0n);
+      await expect(this.mock.$modExp(base, exponent, modulus)).to.be.revertedWithCustomError(
+        this.mock,
+        'MathModulusEqualsZero',
+      );
     });
   });