@paraswap/dex-lib 4.8.37-native-dex-math.1 → 4.8.37

package/native/src/math/tick_math.rs

@@ -1,321 +0,0 @@
-use ethnum::{I256, U256};
-
-pub const MIN_TICK: I256 = I256::new(-887272);
-pub const MAX_TICK: I256 = I256::new(887272);
-pub const MIN_SQRT_RATIO: U256 = U256::new(4295128739u128);
-// 1461446703485210103287273052203988822378723970342
-// = 0xFFFD8963EFD1FC6A506488495D951D5263988D26
-// hi_128 = 0xFFFD8963, lo_128 = 0xEFD1FC6A506488495D951D5263988D26
-pub const MAX_SQRT_RATIO: U256 =
-    U256::from_words(0xFFFD8963, 0xEFD1FC6A506488495D951D5263988D26);
-
-// 2^160 - 1 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
-// hi_128 = 0xFFFFFFFF, lo_128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
-const MASK_160: U256 = U256::from_words(0xFFFFFFFF, u128::MAX);
-
-/// Truncate to uint160 range.
-fn as_uint160(val: U256) -> U256 {
-    val & MASK_160
-}
-
-/// Calculates sqrt(1.0001^tick) * 2^96.
-///
-/// Panics if |tick| > MAX_TICK.
-pub fn get_sqrt_ratio_at_tick(tick: I256) -> U256 {
-    let abs_tick: U256 = if tick < I256::ZERO {
-        (-tick).as_u256()
-    } else {
-        tick.as_u256()
-    };
-
-    assert!(abs_tick <= MAX_TICK.as_u256(), "T");
-
-    let mut ratio: U256 = if (abs_tick & U256::from(0x1u64)) != U256::ZERO {
-        U256::new(0xfffcb933bd6fad37aa2d162d1a594001u128)
-    } else {
-        // 2^128
-        U256::from_words(1, 0)
-    };
-
-    macro_rules! apply_tick_bit {
-        ($bit:expr, $factor:expr) => {
-            if (abs_tick & U256::from($bit as u64)) != U256::ZERO {
-                ratio = (ratio * U256::new($factor)) >> 128;
-            }
-        };
-    }
-
-    apply_tick_bit!(0x2, 0xfff97272373d413259a46990580e213au128);
-    apply_tick_bit!(0x4, 0xfff2e50f5f656932ef12357cf3c7fdccu128);
-    apply_tick_bit!(0x8, 0xffe5caca7e10e4e61c3624eaa0941cd0u128);
-    apply_tick_bit!(0x10, 0xffcb9843d60f6159c9db58835c926644u128);
-    apply_tick_bit!(0x20, 0xff973b41fa98c081472e6896dfb254c0u128);
-    apply_tick_bit!(0x40, 0xff2ea16466c96a3843ec78b326b52861u128);
-    apply_tick_bit!(0x80, 0xfe5dee046a99a2a811c461f1969c3053u128);
-    apply_tick_bit!(0x100, 0xfcbe86c7900a88aedcffc83b479aa3a4u128);
-    apply_tick_bit!(0x200, 0xf987a7253ac413176f2b074cf7815e54u128);
-    apply_tick_bit!(0x400, 0xf3392b0822b70005940c7a398e4b70f3u128);
-    apply_tick_bit!(0x800, 0xe7159475a2c29b7443b29c7fa6e889d9u128);
-    apply_tick_bit!(0x1000, 0xd097f3bdfd2022b8845ad8f792aa5825u128);
-    apply_tick_bit!(0x2000, 0xa9f746462d870fdf8a65dc1f90e061e5u128);
-    apply_tick_bit!(0x4000, 0x70d869a156d2a1b890bb3df62baf32f7u128);
-    apply_tick_bit!(0x8000, 0x31be135f97d08fd981231505542fcfa6u128);
-    apply_tick_bit!(0x10000, 0x9aa508b5b7a84e1c677de54f3e99bc9u128);
-    apply_tick_bit!(0x20000, 0x5d6af8dedb81196699c329225ee604u128);
-    apply_tick_bit!(0x40000, 0x2216e584f5fa1ea926041bedfe98u128);
-    apply_tick_bit!(0x80000, 0x48a170391f7dc42444e8fa2u128);
-
-    if tick > I256::ZERO {
-        ratio = U256::MAX / ratio;
-    }
-
-    let remainder = ratio % (U256::ONE << 32);
-    let extra = if remainder == U256::ZERO {
-        U256::ZERO
-    } else {
-        U256::ONE
-    };
-    as_uint160((ratio >> 32) + extra)
-}
-
-/// Calculates the greatest tick value such that getSqrtRatioAtTick(tick) <= ratio.
-///
-/// Panics if sqrtPriceX96 < MIN_SQRT_RATIO or sqrtPriceX96 >= MAX_SQRT_RATIO.
-pub fn get_tick_at_sqrt_ratio(sqrt_price_x96: U256) -> I256 {
-    assert!(
-        sqrt_price_x96 >= MIN_SQRT_RATIO && sqrt_price_x96 < MAX_SQRT_RATIO,
-        "R"
-    );
-
-    let ratio = sqrt_price_x96 << 32;
-
-    let mut r = ratio;
-    let mut msb = U256::ZERO;
-
-    // _gt helper inline
-    let gt = |a: U256, b: U256| -> U256 {
-        if a > b { U256::ONE } else { U256::ZERO }
-    };
-
-    let mut f: U256 =
-        gt(r, U256::new(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFu128)) << 7;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0xFFFFFFFFFFFFFFFFu128)) << 6;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0xFFFFFFFFu64)) << 5;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0xFFFFu64)) << 4;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0xFFu64)) << 3;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0xFu64)) << 2;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::from(0x3u64)) << 1;
-    msb = msb | f;
-    r = r >> f;
-
-    f = gt(r, U256::ONE);
-    msb = msb | f;
-
-    if msb >= U256::from(128u64) {
-        r = ratio >> (msb - U256::from(127u64));
-    } else {
-        r = ratio << (U256::from(127u64) - msb);
-    }
-
-    // log_2 is int256 in Solidity. (int256(msb) - 128) << 64
-    let mut log_2: I256 = (msb.as_i256() - I256::from(128i32)) << 64u32;
-
-    // 14 iterations of squaring
-    macro_rules! log2_step {
-        ($shift:expr) => {
-            r = (r * r) >> 127;
-            f = r >> 128;
-            // f is 0 or 1 (unsigned), cast to signed for the OR into log_2
-            log_2 = log_2 | ((f.as_i256()) << $shift as u32);
-            r = r >> f;
-        };
-    }
-
-    log2_step!(63);
-    log2_step!(62);
-    log2_step!(61);
-    log2_step!(60);
-    log2_step!(59);
-    log2_step!(58);
-    log2_step!(57);
-    log2_step!(56);
-    log2_step!(55);
-    log2_step!(54);
-    log2_step!(53);
-    log2_step!(52);
-    log2_step!(51);
-
-    // Last iteration (no r >>= f after)
-    r = (r * r) >> 127;
-    f = r >> 128;
-    log_2 = log_2 | ((f.as_i256()) << 50u32);
-
-    // log_sqrt10001 = log_2 * 255738958999603826347141 (signed multiply)
-    let log_sqrt10001: I256 = log_2 * I256::new(255738958999603826347141i128);
-
-    // tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128)
-    let tick_low_raw: I256 = (log_sqrt10001
-        - I256::new(3402992956809132418596140100660247210i128))
-        >> 128u32;
-
-    // tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128)
-    let tick_hi_raw: I256 = (log_sqrt10001
-        + U256::new(291339464771989622907027621153398088495u128).as_i256())
-        >> 128u32;
-
-    let tick_low = as_int_n_24(tick_low_raw);
-    let tick_hi = as_int_n_24(tick_hi_raw);
-
-    if tick_low == tick_hi {
-        tick_low
-    } else if get_sqrt_ratio_at_tick(tick_hi) <= sqrt_price_x96 {
-        tick_hi
-    } else {
-        tick_low
-    }
-}
-
-/// Equivalent to BigInt.asIntN(24, x) -- truncate to 24 bits and sign-extend.
-fn as_int_n_24(x: I256) -> I256 {
-    let mask_24 = I256::new((1i128 << 24) - 1);
-    let truncated = x & mask_24;
-    let sign_bit = I256::ONE << 23u32;
-    if (truncated & sign_bit) != I256::ZERO {
-        truncated | !mask_24
-    } else {
-        truncated
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_constants() {
-        assert_eq!(MIN_TICK, I256::new(-887272));
-        assert_eq!(MAX_TICK, I256::new(887272));
-        assert_eq!(MIN_SQRT_RATIO, U256::from(4295128739u64));
-    }
-
-    #[test]
-    fn test_max_sqrt_ratio() {
-        let expected =
-            U256::from_words(0xFFFD8963, 0xEFD1FC6A506488495D951D5263988D26);
-        assert_eq!(MAX_SQRT_RATIO, expected);
-    }
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_min() {
-        let result = get_sqrt_ratio_at_tick(MIN_TICK);
-        assert_eq!(result, MIN_SQRT_RATIO);
-    }
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_max() {
-        let result = get_sqrt_ratio_at_tick(MAX_TICK);
-        assert_eq!(result, MAX_SQRT_RATIO);
-    }
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_zero() {
-        let result = get_sqrt_ratio_at_tick(I256::ZERO);
-        let q96 = U256::ONE << 96;
-        assert_eq!(result, q96);
-    }
-
-    #[test]
-    fn test_get_tick_at_sqrt_ratio_min() {
-        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO);
-        assert_eq!(result, MIN_TICK);
-    }
-
-    #[test]
-    fn test_get_tick_at_sqrt_ratio_q96() {
-        let q96 = U256::ONE << 96;
-        let result = get_tick_at_sqrt_ratio(q96);
-        assert_eq!(result, I256::ZERO);
-    }
-
-    #[test]
-    fn test_roundtrip_positive_tick() {
-        let tick = I256::from(100i32);
-        let sqrt_ratio = get_sqrt_ratio_at_tick(tick);
-        let computed_tick = get_tick_at_sqrt_ratio(sqrt_ratio);
-        assert_eq!(computed_tick, tick);
-    }
-
-    #[test]
-    fn test_roundtrip_negative_tick() {
-        let tick = I256::from(-100i32);
-        let sqrt_ratio = get_sqrt_ratio_at_tick(tick);
-        let computed_tick = get_tick_at_sqrt_ratio(sqrt_ratio);
-        assert_eq!(computed_tick, tick);
-    }
-
-    #[test]
-    fn test_roundtrip_large_positive_tick() {
-        let tick = I256::new(887270);
-        let sqrt_ratio = get_sqrt_ratio_at_tick(tick);
-        let computed_tick = get_tick_at_sqrt_ratio(sqrt_ratio);
-        assert_eq!(computed_tick, tick);
-    }
-
-    #[test]
-    fn test_roundtrip_large_negative_tick() {
-        let tick = I256::new(-887270);
-        let sqrt_ratio = get_sqrt_ratio_at_tick(tick);
-        let computed_tick = get_tick_at_sqrt_ratio(sqrt_ratio);
-        assert_eq!(computed_tick, tick);
-    }
-
-    #[test]
-    #[should_panic(expected = "T")]
-    fn test_get_sqrt_ratio_at_tick_too_large() {
-        get_sqrt_ratio_at_tick(MAX_TICK + I256::ONE);
-    }
-
-    #[test]
-    #[should_panic(expected = "T")]
-    fn test_get_sqrt_ratio_at_tick_too_small() {
-        get_sqrt_ratio_at_tick(MIN_TICK - I256::ONE);
-    }
-
-    #[test]
-    #[should_panic(expected = "R")]
-    fn test_get_tick_at_sqrt_ratio_too_small() {
-        get_tick_at_sqrt_ratio(MIN_SQRT_RATIO - U256::ONE);
-    }
-
-    #[test]
-    #[should_panic(expected = "R")]
-    fn test_get_tick_at_sqrt_ratio_too_large() {
-        get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
-    }
-
-    #[test]
-    fn test_as_int_n_24() {
-        assert_eq!(as_int_n_24(I256::from(100i32)), I256::from(100i32));
-        assert_eq!(as_int_n_24(I256::from(-100i32)), I256::from(-100i32));
-        assert_eq!(as_int_n_24(I256::new(887272)), I256::new(887272));
-        assert_eq!(as_int_n_24(I256::new(-887272)), I256::new(-887272));
-    }
-}

package/native/src/math/unsafe_math.rs

@@ -1,67 +0,0 @@
-use ethnum::U256;
-
-/// Divides x by y, rounding up. Does not check for division by zero.
-/// Equivalent to Solidity's `(x + y - 1) / y` with unchecked arithmetic.
-pub fn div_rounding_up(x: U256, y: U256) -> U256 {
-    (x + y - U256::ONE) / y
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_exact_division() {
-        assert_eq!(
-            div_rounding_up(U256::from(10u64), U256::from(5u64)),
-            U256::from(2u64)
-        );
-    }
-
-    #[test]
-    fn test_rounds_up() {
-        assert_eq!(
-            div_rounding_up(U256::from(11u64), U256::from(5u64)),
-            U256::from(3u64)
-        );
-    }
-
-    #[test]
-    fn test_one_divided_by_one() {
-        assert_eq!(
-            div_rounding_up(U256::ONE, U256::ONE),
-            U256::ONE
-        );
-    }
-
-    #[test]
-    fn test_zero_numerator() {
-        assert_eq!(
-            div_rounding_up(U256::ZERO, U256::from(5u64)),
-            U256::ZERO
-        );
-    }
-
-    #[test]
-    fn test_large_values() {
-        let _x = U256::MAX;
-        let _y = U256::from(2u64);
-        // (MAX + 2 - 1) / 2 -- but MAX + 1 wraps to 0, so this is (0) / 2 = 0
-        // Wait, U256 arithmetic here is NOT wrapping. Let's think:
-        // x + y - 1 = MAX + 2 - 1 = MAX + 1 which overflows.
-        // But in Solidity "UnsafeMath" this is unchecked. In our TS it uses BigInt (no overflow).
-        // TS: (MAX + 2 - 1) / 2 = (MAX + 1) / 2 = 2^256 / 2 = 2^255.
-        // But U256 can't represent 2^256. The TS BigInt can though.
-        // Actually in the TS, x is already bounded to uint256 values that come from
-        // other operations, so x + y - 1 wouldn't overflow in practice.
-        // We skip this edge case test.
-    }
-
-    #[test]
-    fn test_rounding_by_one() {
-        assert_eq!(
-            div_rounding_up(U256::from(1u64), U256::from(3u64)),
-            U256::from(1u64)
-        );
-    }
-}

package/native/src/pool_state.rs

@@ -1,41 +0,0 @@
-use ethnum::{I256, U256};
-use std::collections::HashMap;
-
-use crate::config::MathVariant;
-use crate::math::oracle::OracleObservation;
-use crate::math::tick::TickInfo;
-
-/// Mirrors the TS PoolState type, containing all fields needed for pricing.
-/// balance0/balance1 are NOT included — they stay in JS.
-#[derive(Debug, Clone)]
-pub struct PoolState {
-    pub block_timestamp: U256,
-    pub tick_spacing: I256,
-    pub fee: U256,
-
-    // slot0
-    pub sqrt_price_x96: U256,
-    pub tick: I256,
-    pub observation_index: u16,
-    pub observation_cardinality: u16,
-    pub observation_cardinality_next: u16,
-    pub fee_protocol: U256,
-
-    pub liquidity: U256,
-    pub max_liquidity_per_tick: U256,
-
-    pub tick_bitmap: HashMap<i16, U256>,
-    pub ticks: HashMap<i32, TickInfo>,
-    pub observations: HashMap<u16, OracleObservation>,
-
-    pub start_tick_bitmap: I256,
-    pub lowest_known_tick: I256,
-    pub highest_known_tick: I256,
-
-    /// Precomputed bitmap bounds for price queries.
-    /// wordPos must be within [bitmap_range_lower, bitmap_range_upper] during pricing.
-    pub bitmap_range_lower: i16,
-    pub bitmap_range_upper: i16,
-
-    pub variant: MathVariant,
-}