feat(cheatcodes): extend usable range in assertApproxEqRel

crates/cheatcodes/src/test/assert.rs

@@ -1,5 +1,5 @@
 use crate::{CheatcodesExecutor, CheatsCtxt, Result, Vm::*};
-use alloy_primitives::{hex, I256, U256};
+use alloy_primitives::{hex, I256, U256, U512};
 use foundry_evm_core::{
     abi::console::{format_units_int, format_units_uint},
     backend::GLOBAL_FAIL_SLOT,
@@ -484,14 +484,6 @@ fn assert_not_eq<'a, T: PartialEq>(left: &'a T, right: &'a T) -> ComparisonResul
     }
 }
 
-fn get_delta_uint(left: U256, right: U256) -> U256 {
-    if left > right {
-        left - right
-    } else {
-        right - left
-    }
-}
-
 fn get_delta_int(left: I256, right: I256) -> U256 {
     let (left_sign, left_abs) = left.into_sign_and_abs();
     let (right_sign, right_abs) = right.into_sign_and_abs();
@@ -507,12 +499,21 @@ fn get_delta_int(left: I256, right: I256) -> U256 {
     }
 }
 
+/// Calculates the relative delta for an absolute difference.
+///
+/// Avoids overflow in the multiplication by using [`U512`] to hold the intermediary result.
+fn calc_delta_full<T>(abs_diff: U256, right: U256) -> Result<U256, EqRelAssertionError<T>> {
+    let delta = U512::from(abs_diff) * U512::from(10).pow(U512::from(EQ_REL_DELTA_RESOLUTION)) /
+        U512::from(right);
+    U256::checked_from_limbs_slice(delta.as_limbs()).ok_or(EqRelAssertionError::Overflow)
+}
+
 fn uint_assert_approx_eq_abs(
     left: U256,
     right: U256,
     max_delta: U256,
 ) -> Result<Vec<u8>, Box<EqAbsAssertionError<U256, U256>>> {
-    let delta = get_delta_uint(left, right);
+    let delta = left.abs_diff(right);
 
     if delta <= max_delta {
         Ok(Default::default())
@@ -553,10 +554,7 @@ fn uint_assert_approx_eq_rel(
         };
     }
 
-    let delta = get_delta_uint(left, right)
-        .checked_mul(U256::pow(U256::from(10), EQ_REL_DELTA_RESOLUTION))
-        .ok_or(EqRelAssertionError::Overflow)? /
-        right;
+    let delta = calc_delta_full::<U256>(left.abs_diff(right), right)?;
 
     if delta <= max_delta {
         Ok(Default::default())
@@ -588,11 +586,7 @@ fn int_assert_approx_eq_rel(
         }
     }
 
-    let (_, abs_right) = right.into_sign_and_abs();
-    let delta = get_delta_int(left, right)
-        .checked_mul(U256::pow(U256::from(10), EQ_REL_DELTA_RESOLUTION))
-        .ok_or(EqRelAssertionError::Overflow)? /
-        abs_right;
+    let delta = calc_delta_full::<I256>(get_delta_int(left, right), right.unsigned_abs())?;
 
     if delta <= max_delta {
         Ok(Default::default())

testdata/default/cheats/Assert.t.sol

@@ -804,22 +804,18 @@ contract AssertionsTest is DSTest {
     }
 
     function testAssertApproxEqRel() public {
-        vm._expectCheatcodeRevert(bytes("assertion failed: overflow in delta calculation"));
-        vm.assertApproxEqRel(type(int256).min, type(int256).max, 0);
-
         vm._expectCheatcodeRevert(
             bytes(string.concat(errorMessage, ": 1 !~= 0 (max delta: 0.0000000000000000%, real delta: undefined)"))
         );
         vm.assertApproxEqRel(int256(1), int256(0), 0, errorMessage);
 
-        vm._expectCheatcodeRevert(bytes(string.concat(errorMessage, ": overflow in delta calculation")));
-        vm.assertApproxEqRel(uint256(0), type(uint256).max, 0, errorMessage);
-
         vm._expectCheatcodeRevert(
             bytes("assertion failed: 1 !~= 0 (max delta: 0.0000000000000000%, real delta: undefined)")
         );
         vm.assertApproxEqRel(uint256(1), uint256(0), uint256(0));
 
+        vm.assertApproxEqRel(type(int256).min, type(int256).max, 2e18);
+        vm.assertApproxEqRel(uint256(0), type(uint256).max, 1e18);
         vm.assertApproxEqRel(uint256(0), uint256(0), uint256(0));
     }
 }