@paraswap/dex-lib 5.0.1-new-dexs-encoding.0 → 5.0.2-native-dex-math.0

package/native/src/math/full_math.rs

@@ -0,0 +1,217 @@
+use ethnum::U256;
+
+/// Calculates floor(a * b / denominator).
+///
+/// The TS version uses BigInt which has arbitrary precision, so `a * b` never
+/// overflows. We replicate this by widening to 512-bit via two U256 halves.
+///
+/// Panics if the result exceeds U256::MAX or denominator is zero.
+pub fn mul_div(a: U256, b: U256, denominator: U256) -> U256 {
+    assert!(denominator > U256::ZERO, "denominator must be > 0");
+    let (lo, hi) = widening_mul(a, b);
+    let (quot, _) = div_512_by_256(lo, hi, denominator);
+    quot
+}
+
+/// Calculates ceil(a * b / denominator).
+///
+/// Panics if the result exceeds U256::MAX or denominator is zero.
+pub fn mul_div_rounding_up(a: U256, b: U256, denominator: U256) -> U256 {
+    assert!(denominator > U256::ZERO, "denominator must be > 0");
+    // result = (a * b + denominator - 1) / denominator
+    let (lo, hi) = widening_mul(a, b);
+    // add (denominator - 1) to the 512-bit product
+    let addend = denominator - U256::ONE;
+    let (lo2, carry) = lo.overflowing_add(addend);
+    let hi2 = if carry { hi + U256::ONE } else { hi };
+    let (quot, _) = div_512_by_256(lo2, hi2, denominator);
+    quot
+}
+
+/// Returns (lo, hi) such that a * b = hi * 2^256 + lo.
+fn widening_mul(a: U256, b: U256) -> (U256, U256) {
+    let mask128 = (U256::ONE << 128) - U256::ONE;
+
+    let a_lo = a & mask128;
+    let a_hi = a >> 128;
+    let b_lo = b & mask128;
+    let b_hi = b >> 128;
+
+    let p0: U256 = a_lo * b_lo;
+    let p1: U256 = a_lo * b_hi;
+    let p2: U256 = a_hi * b_lo;
+    let p3: U256 = a_hi * b_hi;
+
+    let lo: U256 = p0;
+    let hi: U256 = p3;
+
+    // Add p1 << 128
+    let p1_lo = p1 << 128;
+    let p1_hi = p1 >> 128;
+    let (lo, c1) = lo.overflowing_add(p1_lo);
+    let hi = hi + p1_hi + if c1 { U256::ONE } else { U256::ZERO };
+
+    // Add p2 << 128
+    let p2_lo = p2 << 128;
+    let p2_hi = p2 >> 128;
+    let (lo, c2) = lo.overflowing_add(p2_lo);
+    let hi = hi + p2_hi + if c2 { U256::ONE } else { U256::ZERO };
+
+    (lo, hi)
+}
+
+/// Divides a 512-bit number (lo + hi * 2^256) by a 256-bit denominator.
+/// Returns (quotient, remainder). Panics if quotient overflows U256.
+fn div_512_by_256(lo: U256, hi: U256, d: U256) -> (U256, U256) {
+    assert!(d > U256::ZERO, "division by zero");
+
+    if hi == U256::ZERO {
+        return (lo / d, lo % d);
+    }
+
+    assert!(hi < d, "mul_div result overflows U256");
+
+    // Split lo into two 128-bit halves and do two rounds of division.
+    let mask128 = (U256::ONE << 128) - U256::ONE;
+    let lo_hi = (lo >> 128) & mask128;
+    let lo_lo = lo & mask128;
+
+    // First round: divide (hi * 2^128 + lo_hi) by d
+    let (q_hi, r1) = div_384_by_256(lo_hi, hi, d);
+
+    // Second round: divide (r1 * 2^128 + lo_lo) by d
+    let (q_lo, rem) = div_384_by_256(lo_lo, r1, d);
+
+    let quotient = (q_hi << 128) + q_lo;
+    (quotient, rem)
+}
+
+/// Divides (hi * 2^128 + lo_128) by d, where hi < d and lo_128 < 2^128.
+/// Returns (quotient, remainder).
+fn div_384_by_256(lo_128: U256, hi: U256, d: U256) -> (U256, U256) {
+    let mask128 = (U256::ONE << 128) - U256::ONE;
+    let hi_upper = hi >> 128;
+
+    if hi_upper == U256::ZERO {
+        // hi fits in 128 bits, so hi * 2^128 + lo_128 fits in 256 bits
+        let numerator = (hi << 128) | lo_128;
+        return (numerator / d, numerator % d);
+    }
+
+    // hi doesn't fit in 128 bits. Use bit-by-bit long division.
+    // The quotient fits in at most ~129 bits (since hi < d).
+    let _ = mask128;
+    let mut remainder = hi;
+    let mut quotient = U256::ZERO;
+
+    for i in (0..128).rev() {
+        let bit = (lo_128 >> i) & U256::ONE;
+
+        // Check if shifting left would overflow
+        let overflow = remainder >> 255 != U256::ZERO;
+        remainder = (remainder << 1) | bit;
+
+        if overflow || remainder >= d {
+            remainder = remainder.wrapping_sub(d);
+            quotient = quotient | (U256::ONE << i);
+        }
+    }
+
+    (quotient, remainder)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mul_div_simple() {
+        assert_eq!(
+            mul_div(U256::from(6u64), U256::from(7u64), U256::from(3u64)),
+            U256::from(14u64)
+        );
+    }
+
+    #[test]
+    fn test_mul_div_large() {
+        assert_eq!(
+            mul_div(U256::MAX, U256::ONE, U256::ONE),
+            U256::MAX
+        );
+    }
+
+    #[test]
+    fn test_mul_div_rounding_up_exact() {
+        assert_eq!(
+            mul_div_rounding_up(U256::from(6u64), U256::from(7u64), U256::from(3u64)),
+            U256::from(14u64)
+        );
+    }
+
+    #[test]
+    fn test_mul_div_rounding_up_rounds() {
+        // 5 * 7 / 3 = 35/3 = 11.666... -> ceil = 12
+        assert_eq!(
+            mul_div_rounding_up(U256::from(5u64), U256::from(7u64), U256::from(3u64)),
+            U256::from(12u64)
+        );
+    }
+
+    #[test]
+    fn test_mul_div_floor() {
+        // 5 * 7 / 3 = 35/3 = 11.666... -> floor = 11
+        assert_eq!(
+            mul_div(U256::from(5u64), U256::from(7u64), U256::from(3u64)),
+            U256::from(11u64)
+        );
+    }
+
+    #[test]
+    fn test_mul_div_large_product() {
+        let a = U256::ONE << 200;
+        let b = U256::ONE << 200;
+        let d = U256::ONE << 200;
+        assert_eq!(mul_div(a, b, d), U256::ONE << 200);
+    }
+
+    #[test]
+    fn test_mul_div_max_times_max() {
+        assert_eq!(mul_div(U256::MAX, U256::MAX, U256::MAX), U256::MAX);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_mul_div_overflow() {
+        mul_div(U256::MAX, U256::MAX, U256::ONE);
+    }
+
+    #[test]
+    fn test_mul_div_rounding_up_large() {
+        let a = U256::ONE << 128;
+        let b = U256::ONE << 128;
+        let d = (U256::ONE << 128) + U256::ONE;
+        let result = mul_div_rounding_up(a, b, d);
+        assert!(result > U256::ZERO);
+    }
+
+    #[test]
+    fn test_widening_mul_simple() {
+        let (lo, hi) = widening_mul(U256::from(3u64), U256::from(7u64));
+        assert_eq!(lo, U256::from(21u64));
+        assert_eq!(hi, U256::ZERO);
+    }
+
+    #[test]
+    fn test_widening_mul_large() {
+        let (lo, hi) = widening_mul(U256::MAX, U256::from(2u64));
+        assert_eq!(hi, U256::ONE);
+        assert_eq!(lo, U256::MAX - U256::ONE);
+    }
+
+    #[test]
+    fn test_mul_div_uniswap_style() {
+        // Test case from Uniswap V3: mulDiv(Q128, Q128, Q128) = Q128
+        let q128 = U256::ONE << 128;
+        assert_eq!(mul_div(q128, q128, q128), q128);
+    }
+}

package/native/src/math/liquidity_math.rs

@@ -0,0 +1,72 @@
+use ethnum::{I256, U256};
+
+/// Adds a signed liquidity delta to an unsigned liquidity value.
+///
+/// In Solidity, when y < 0:
+///   z = x - uint128(-y); require(z < x)
+/// When y >= 0:
+///   z = x + uint128(y); require(z >= x)
+///
+/// Panics with "LS" if y < 0 and the subtraction underflows.
+/// Panics with "LA" if y >= 0 and the addition overflows.
+pub fn add_delta(x: U256, y: I256) -> U256 {
+    let mask_128: U256 = (U256::ONE << 128) - U256::ONE;
+
+    if y < I256::ZERO {
+        // _y = BigInt.asUintN(128, -y)
+        // (-y) is positive I256; reinterpret as U256 and mask to 128 bits
+        let neg_y_u256 = (-y).as_u256();
+        let _y = neg_y_u256 & mask_128;
+        let z = x.checked_sub(_y).expect("LS");
+        assert!(z < x, "LS");
+        z
+    } else {
+        // _y = BigInt.asUintN(128, y)
+        let _y = y.as_u256() & mask_128;
+        let z = x.checked_add(_y).expect("LA");
+        assert!(z >= x, "LA");
+        z
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_positive_delta() {
+        let x = U256::from(100u64);
+        let y = I256::new(50);
+        assert_eq!(add_delta(x, y), U256::from(150u64));
+    }
+
+    #[test]
+    fn test_add_negative_delta() {
+        let x = U256::from(100u64);
+        let y = I256::new(-50);
+        assert_eq!(add_delta(x, y), U256::from(50u64));
+    }
+
+    #[test]
+    fn test_add_zero_delta() {
+        let x = U256::from(100u64);
+        let y = I256::ZERO;
+        assert_eq!(add_delta(x, y), U256::from(100u64));
+    }
+
+    #[test]
+    #[should_panic(expected = "LS")]
+    fn test_subtract_too_much() {
+        let x = U256::from(50u64);
+        let y = I256::new(-100);
+        add_delta(x, y);
+    }
+
+    #[test]
+    #[should_panic(expected = "LA")]
+    fn test_add_overflow() {
+        let x = U256::MAX;
+        let y = I256::new(1);
+        add_delta(x, y);
+    }
+}

package/native/src/math/mod.rs

@@ -0,0 +1,10 @@
+pub mod bit_math;
+pub mod full_math;
+pub mod liquidity_math;
+pub mod sqrt_price_math;
+pub mod swap_math;
+pub mod tick;
+pub mod tick_bitmap;
+pub mod tick_math;
+pub mod unsafe_math;
+pub mod oracle;