@paraswap/dex-lib 4.8.36 → 4.8.37-native-dex-math.0

package/native/src/math/sqrt_price_math.rs

@@ -0,0 +1,272 @@
+use ethnum::{I256, U256};
+use super::full_math;
+use super::unsafe_math;
+
+const RESOLUTION: u32 = 96;
+const Q96: U256 = U256::from_words(0, 1u128 << 96);
+// 2^160 - 1: hi_128 = 0xFFFFFFFF, lo_128 = u128::MAX
+const MAX_UINT160: U256 = U256::from_words(0xFFFFFFFF, u128::MAX);
+
+/// Truncate to uint160 range.
+fn as_uint160(val: U256) -> U256 {
+    val & MAX_UINT160
+}
+
+pub fn get_next_sqrt_price_from_amount0_rounding_up(
+    sqrt_p_x96: U256,
+    liquidity: U256,
+    amount: U256,
+    add: bool,
+) -> U256 {
+    if amount == U256::ZERO {
+        return sqrt_p_x96;
+    }
+    let numerator1 = liquidity << RESOLUTION;
+
+    let product = amount * sqrt_p_x96;
+    if add {
+        if product / amount == sqrt_p_x96 {
+            let denominator = numerator1 + product;
+            if denominator >= numerator1 {
+                return as_uint160(full_math::mul_div_rounding_up(
+                    numerator1,
+                    sqrt_p_x96,
+                    denominator,
+                ));
+            }
+        }
+        as_uint160(unsafe_math::div_rounding_up(
+            numerator1,
+            numerator1 / sqrt_p_x96 + amount,
+        ))
+    } else {
+        assert!(
+            product / amount == sqrt_p_x96 && numerator1 > product,
+            "product / amount == sqrt_p_x96 && numerator1 > product"
+        );
+        let denominator = numerator1 - product;
+        as_uint160(full_math::mul_div_rounding_up(
+            numerator1,
+            sqrt_p_x96,
+            denominator,
+        ))
+    }
+}
+
+pub fn get_next_sqrt_price_from_amount1_rounding_down(
+    sqrt_p_x96: U256,
+    liquidity: U256,
+    amount: U256,
+    add: bool,
+) -> U256 {
+    if add {
+        let quotient = if amount <= MAX_UINT160 {
+            (amount << RESOLUTION) / liquidity
+        } else {
+            full_math::mul_div(amount, Q96, liquidity)
+        };
+        as_uint160(sqrt_p_x96 + quotient)
+    } else {
+        let quotient = if amount <= MAX_UINT160 {
+            unsafe_math::div_rounding_up(amount << RESOLUTION, liquidity)
+        } else {
+            full_math::mul_div_rounding_up(amount, Q96, liquidity)
+        };
+        assert!(sqrt_p_x96 > quotient, "sqrt_p_x96 > quotient");
+        as_uint160(sqrt_p_x96 - quotient)
+    }
+}
+
+pub fn get_next_sqrt_price_from_input(
+    sqrt_p_x96: U256,
+    liquidity: U256,
+    amount_in: U256,
+    zero_for_one: bool,
+) -> U256 {
+    assert!(sqrt_p_x96 > U256::ZERO, "sqrt_p_x96 > 0");
+    assert!(liquidity > U256::ZERO, "liquidity > 0");
+
+    if zero_for_one {
+        get_next_sqrt_price_from_amount0_rounding_up(sqrt_p_x96, liquidity, amount_in, true)
+    } else {
+        get_next_sqrt_price_from_amount1_rounding_down(sqrt_p_x96, liquidity, amount_in, true)
+    }
+}
+
+pub fn get_next_sqrt_price_from_output(
+    sqrt_p_x96: U256,
+    liquidity: U256,
+    amount_out: U256,
+    zero_for_one: bool,
+) -> U256 {
+    assert!(sqrt_p_x96 > U256::ZERO, "sqrt_p_x96 > 0");
+    assert!(liquidity > U256::ZERO, "liquidity > 0");
+
+    if zero_for_one {
+        get_next_sqrt_price_from_amount1_rounding_down(sqrt_p_x96, liquidity, amount_out, false)
+    } else {
+        get_next_sqrt_price_from_amount0_rounding_up(sqrt_p_x96, liquidity, amount_out, false)
+    }
+}
+
+pub fn get_amount0_delta(
+    sqrt_ratio_a_x96: U256,
+    sqrt_ratio_b_x96: U256,
+    liquidity: U256,
+    round_up: bool,
+) -> U256 {
+    let (sqrt_ratio_a_x96, sqrt_ratio_b_x96) = if sqrt_ratio_a_x96 > sqrt_ratio_b_x96 {
+        (sqrt_ratio_b_x96, sqrt_ratio_a_x96)
+    } else {
+        (sqrt_ratio_a_x96, sqrt_ratio_b_x96)
+    };
+
+    let numerator1 = liquidity << RESOLUTION;
+    let numerator2 = sqrt_ratio_b_x96 - sqrt_ratio_a_x96;
+
+    assert!(sqrt_ratio_a_x96 > U256::ZERO, "sqrt_ratio_a_x96 > 0");
+
+    if round_up {
+        unsafe_math::div_rounding_up(
+            full_math::mul_div_rounding_up(numerator1, numerator2, sqrt_ratio_b_x96),
+            sqrt_ratio_a_x96,
+        )
+    } else {
+        full_math::mul_div(numerator1, numerator2, sqrt_ratio_b_x96) / sqrt_ratio_a_x96
+    }
+}
+
+pub fn get_amount1_delta(
+    sqrt_ratio_a_x96: U256,
+    sqrt_ratio_b_x96: U256,
+    liquidity: U256,
+    round_up: bool,
+) -> U256 {
+    let (sqrt_ratio_a_x96, sqrt_ratio_b_x96) = if sqrt_ratio_a_x96 > sqrt_ratio_b_x96 {
+        (sqrt_ratio_b_x96, sqrt_ratio_a_x96)
+    } else {
+        (sqrt_ratio_a_x96, sqrt_ratio_b_x96)
+    };
+
+    if round_up {
+        full_math::mul_div_rounding_up(
+            liquidity,
+            sqrt_ratio_b_x96 - sqrt_ratio_a_x96,
+            Q96,
+        )
+    } else {
+        full_math::mul_div(liquidity, sqrt_ratio_b_x96 - sqrt_ratio_a_x96, Q96)
+    }
+}
+
+/// Signed version: _getAmount0DeltaO with signed liquidity.
+/// Equivalent to TS SqrtPriceMath._getAmount0DeltaO.
+pub fn get_amount0_delta_signed(
+    sqrt_ratio_a_x96: U256,
+    sqrt_ratio_b_x96: U256,
+    liquidity: I256,
+) -> I256 {
+    let mask_128 = (U256::ONE << 128) - U256::ONE;
+    if liquidity < I256::ZERO {
+        // BigInt.asUintN(128, -liquidity)
+        let abs_liq = (-liquidity).as_u256() & mask_128;
+        let delta = get_amount0_delta(sqrt_ratio_a_x96, sqrt_ratio_b_x96, abs_liq, false);
+        // -BigInt.asIntN(256, delta)
+        -(delta.as_i256())
+    } else {
+        // BigInt.asUintN(128, liquidity)
+        let liq_u = liquidity.as_u256() & mask_128;
+        let delta = get_amount0_delta(sqrt_ratio_a_x96, sqrt_ratio_b_x96, liq_u, true);
+        // BigInt.asIntN(256, delta)
+        delta.as_i256()
+    }
+}
+
+/// Signed version: _getAmount1DeltaO with signed liquidity.
+/// Equivalent to TS SqrtPriceMath._getAmount1DeltaO.
+pub fn get_amount1_delta_signed(
+    sqrt_ratio_a_x96: U256,
+    sqrt_ratio_b_x96: U256,
+    liquidity: I256,
+) -> I256 {
+    let mask_128 = (U256::ONE << 128) - U256::ONE;
+    if liquidity < I256::ZERO {
+        let abs_liq = (-liquidity).as_u256() & mask_128;
+        let delta = get_amount1_delta(sqrt_ratio_a_x96, sqrt_ratio_b_x96, abs_liq, false);
+        -(delta.as_i256())
+    } else {
+        let liq_u = liquidity.as_u256() & mask_128;
+        let delta = get_amount1_delta(sqrt_ratio_a_x96, sqrt_ratio_b_x96, liq_u, true);
+        delta.as_i256()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_amount0_delta_basic() {
+        let sqrt_a = U256::from(79228162514264337593543950336u128); // Q96 * 1
+        let sqrt_b = U256::from(158456325028528675187087900672u128); // Q96 * 2
+        let liquidity = U256::from(1_000_000u64);
+        let result = get_amount0_delta(sqrt_a, sqrt_b, liquidity, true);
+        assert!(result > U256::ZERO);
+    }
+
+    #[test]
+    fn test_get_amount1_delta_basic() {
+        let sqrt_a = U256::from(79228162514264337593543950336u128); // Q96 * 1
+        let sqrt_b = U256::from(158456325028528675187087900672u128); // Q96 * 2
+        let liquidity = U256::from(1_000_000u64);
+        let result = get_amount1_delta(sqrt_a, sqrt_b, liquidity, true);
+        assert!(result > U256::ZERO);
+    }
+
+    #[test]
+    fn test_get_next_sqrt_price_from_input_zero_for_one() {
+        let sqrt_p = U256::from(79228162514264337593543950336u128);
+        let liquidity = U256::from(1_000_000_000_000u64);
+        let amount = U256::from(1_000_000u64);
+        let result = get_next_sqrt_price_from_input(sqrt_p, liquidity, amount, true);
+        assert!(result > U256::ZERO);
+        assert!(result <= sqrt_p);
+    }
+
+    #[test]
+    fn test_get_next_sqrt_price_from_input_one_for_zero() {
+        let sqrt_p = U256::from(79228162514264337593543950336u128);
+        let liquidity = U256::from(1_000_000_000_000u64);
+        let amount = U256::from(1_000_000u64);
+        let result = get_next_sqrt_price_from_input(sqrt_p, liquidity, amount, false);
+        assert!(result >= sqrt_p);
+    }
+
+    #[test]
+    fn test_get_amount0_delta_symmetric() {
+        let sqrt_a = U256::from(79228162514264337593543950336u128);
+        let sqrt_b = U256::from(158456325028528675187087900672u128);
+        let liquidity = U256::from(1_000_000u64);
+        let r1 = get_amount0_delta(sqrt_a, sqrt_b, liquidity, true);
+        let r2 = get_amount0_delta(sqrt_b, sqrt_a, liquidity, true);
+        assert_eq!(r1, r2);
+    }
+
+    #[test]
+    fn test_get_amount0_delta_signed_positive() {
+        let sqrt_a = U256::from(79228162514264337593543950336u128);
+        let sqrt_b = U256::from(158456325028528675187087900672u128);
+        let liquidity = I256::from(1_000_000i64);
+        let result = get_amount0_delta_signed(sqrt_a, sqrt_b, liquidity);
+        assert!(result > I256::ZERO);
+    }
+
+    #[test]
+    fn test_get_amount0_delta_signed_negative() {
+        let sqrt_a = U256::from(79228162514264337593543950336u128);
+        let sqrt_b = U256::from(158456325028528675187087900672u128);
+        let liquidity = I256::from(-1_000_000i64);
+        let result = get_amount0_delta_signed(sqrt_a, sqrt_b, liquidity);
+        assert!(result < I256::ZERO);
+    }
+}

package/native/src/math/swap_math.rs

@@ -0,0 +1,306 @@
+use ethnum::{I256, U256};
+use super::full_math;
+use super::sqrt_price_math;
+
+/// Result of a single swap step computation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SwapStepResult {
+    pub sqrt_ratio_next_x96: U256,
+    pub amount_in: U256,
+    pub amount_out: U256,
+    pub fee_amount: U256,
+}
+
+/// BI_POWS[6] = 1_000_000
+const ONE_MILLION: U256 = U256::new(1_000_000u128);
+
+/// Computes the result of swapping some amount in, or amount out, given the parameters of the swap.
+///
+/// The fee, `fee_pips`, is in hundredths of a bip (i.e. 1e-6).
+///
+/// `amount_remaining` is treated as an I256: positive means exact-input, negative means exact-output.
+pub fn compute_swap_step(
+    sqrt_ratio_current_x96: U256,
+    sqrt_ratio_target_x96: U256,
+    liquidity: U256,
+    amount_remaining: I256,
+    fee_pips: U256,
+) -> SwapStepResult {
+    let zero_for_one = sqrt_ratio_current_x96 >= sqrt_ratio_target_x96;
+    let exact_in = amount_remaining >= I256::ZERO;
+
+    let sqrt_ratio_next_x96;
+    let mut amount_in;
+    let mut amount_out;
+    let fee_amount;
+
+    if exact_in {
+        // BigInt.asUintN(256, amountRemaining) -- amountRemaining is non-negative here so it's identity
+        let amount_remaining_u = amount_remaining.as_u256();
+        let amount_remaining_less_fee =
+            full_math::mul_div(amount_remaining_u, ONE_MILLION - fee_pips, ONE_MILLION);
+
+        amount_in = if zero_for_one {
+            sqrt_price_math::get_amount0_delta(
+                sqrt_ratio_target_x96,
+                sqrt_ratio_current_x96,
+                liquidity,
+                true,
+            )
+        } else {
+            sqrt_price_math::get_amount1_delta(
+                sqrt_ratio_current_x96,
+                sqrt_ratio_target_x96,
+                liquidity,
+                true,
+            )
+        };
+
+        if amount_remaining_less_fee >= amount_in {
+            sqrt_ratio_next_x96 = sqrt_ratio_target_x96;
+        } else {
+            sqrt_ratio_next_x96 = sqrt_price_math::get_next_sqrt_price_from_input(
+                sqrt_ratio_current_x96,
+                liquidity,
+                amount_remaining_less_fee,
+                zero_for_one,
+            );
+        }
+    } else {
+        // BigInt.asUintN(256, -amountRemaining) -- negate signed, interpret as unsigned
+        let neg_amount = (-amount_remaining).as_u256();
+
+        amount_out = if zero_for_one {
+            sqrt_price_math::get_amount1_delta(
+                sqrt_ratio_target_x96,
+                sqrt_ratio_current_x96,
+                liquidity,
+                false,
+            )
+        } else {
+            sqrt_price_math::get_amount0_delta(
+                sqrt_ratio_current_x96,
+                sqrt_ratio_target_x96,
+                liquidity,
+                false,
+            )
+        };
+
+        if neg_amount >= amount_out {
+            sqrt_ratio_next_x96 = sqrt_ratio_target_x96;
+        } else {
+            sqrt_ratio_next_x96 = sqrt_price_math::get_next_sqrt_price_from_output(
+                sqrt_ratio_current_x96,
+                liquidity,
+                neg_amount,
+                zero_for_one,
+            );
+        }
+
+        // Initialize amount_in to 0; it will be set below
+        amount_in = U256::ZERO;
+    }
+
+    // Re-initialize for the second half of the function
+    // We need to track amount_out properly for the !exact_in case
+    // The TS code re-computes both amount_in and amount_out based on `max` flag
+    let max = sqrt_ratio_target_x96 == sqrt_ratio_next_x96;
+
+    if exact_in {
+        // amount_out was not set in exact_in path above, initialize to 0
+        amount_out = U256::ZERO;
+    } else {
+        amount_out = if zero_for_one {
+            sqrt_price_math::get_amount1_delta(
+                sqrt_ratio_target_x96,
+                sqrt_ratio_current_x96,
+                liquidity,
+                false,
+            )
+        } else {
+            sqrt_price_math::get_amount0_delta(
+                sqrt_ratio_current_x96,
+                sqrt_ratio_target_x96,
+                liquidity,
+                false,
+            )
+        };
+    }
+
+    if zero_for_one {
+        if !(max && exact_in) {
+            amount_in = sqrt_price_math::get_amount0_delta(
+                sqrt_ratio_next_x96,
+                sqrt_ratio_current_x96,
+                liquidity,
+                true,
+            );
+        }
+        if !(max && !exact_in) {
+            amount_out = sqrt_price_math::get_amount1_delta(
+                sqrt_ratio_next_x96,
+                sqrt_ratio_current_x96,
+                liquidity,
+                false,
+            );
+        }
+    } else {
+        if !(max && exact_in) {
+            amount_in = sqrt_price_math::get_amount1_delta(
+                sqrt_ratio_current_x96,
+                sqrt_ratio_next_x96,
+                liquidity,
+                true,
+            );
+        }
+        if !(max && !exact_in) {
+            amount_out = sqrt_price_math::get_amount0_delta(
+                sqrt_ratio_current_x96,
+                sqrt_ratio_next_x96,
+                liquidity,
+                false,
+            );
+        }
+    }
+
+    // Cap the output amount to not exceed the remaining output amount
+    if !exact_in {
+        let neg_amount = (-amount_remaining).as_u256();
+        if amount_out > neg_amount {
+            amount_out = neg_amount;
+        }
+    }
+
+    if exact_in && sqrt_ratio_next_x96 != sqrt_ratio_target_x96 {
+        // We didn't reach the target, so take the remainder of the maximum input as fee
+        fee_amount = amount_remaining.as_u256() - amount_in;
+    } else {
+        fee_amount =
+            full_math::mul_div_rounding_up(amount_in, fee_pips, ONE_MILLION - fee_pips);
+    }
+
+    SwapStepResult {
+        sqrt_ratio_next_x96,
+        amount_in,
+        amount_out,
+        fee_amount,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Q96 = 2^96
+    const Q96: U256 = U256::from_words(0, 1u128 << 96);
+
+    #[test]
+    fn test_exact_in_zero_for_one() {
+        // price moves from 2.0 toward 1.0
+        let sqrt_current = Q96 * U256::from(2u64); // sqrt(4) * Q96
+        let sqrt_target = Q96; // sqrt(1) * Q96
+        let liquidity = U256::from(1_000_000_000_000u128);
+        let amount_remaining = I256::from(1_000_000i64);
+        let fee_pips = U256::from(3000u64); // 0.3%
+
+        let result = compute_swap_step(
+            sqrt_current,
+            sqrt_target,
+            liquidity,
+            amount_remaining,
+            fee_pips,
+        );
+
+        assert!(result.sqrt_ratio_next_x96 > U256::ZERO);
+        assert!(result.sqrt_ratio_next_x96 <= sqrt_current);
+        assert!(result.amount_in > U256::ZERO);
+        assert!(result.amount_out > U256::ZERO);
+        // amount_in + fee_amount should not exceed amount_remaining
+        assert!(result.amount_in + result.fee_amount <= amount_remaining.as_u256());
+    }
+
+    #[test]
+    fn test_exact_out_zero_for_one() {
+        let sqrt_current = Q96 * U256::from(2u64);
+        let sqrt_target = Q96;
+        let liquidity = U256::from(1_000_000_000_000u128);
+        let amount_remaining = I256::from(-500_000i64); // exact output
+        let fee_pips = U256::from(3000u64);
+
+        let result = compute_swap_step(
+            sqrt_current,
+            sqrt_target,
+            liquidity,
+            amount_remaining,
+            fee_pips,
+        );
+
+        assert!(result.sqrt_ratio_next_x96 > U256::ZERO);
+        assert!(result.amount_in > U256::ZERO);
+        assert!(result.amount_out > U256::ZERO);
+        // amount_out should not exceed requested
+        assert!(result.amount_out <= U256::from(500_000u64));
+    }
+
+    #[test]
+    fn test_exact_in_one_for_zero() {
+        let sqrt_current = Q96;
+        let sqrt_target = Q96 * U256::from(2u64);
+        let liquidity = U256::from(1_000_000_000_000u128);
+        let amount_remaining = I256::from(1_000_000i64);
+        let fee_pips = U256::from(3000u64);
+
+        let result = compute_swap_step(
+            sqrt_current,
+            sqrt_target,
+            liquidity,
+            amount_remaining,
+            fee_pips,
+        );
+
+        assert!(result.sqrt_ratio_next_x96 >= sqrt_current);
+        assert!(result.amount_in > U256::ZERO);
+        assert!(result.amount_out > U256::ZERO);
+    }
+
+    #[test]
+    fn test_fee_amount_when_target_not_reached() {
+        // Very small liquidity so we definitely reach the target
+        let sqrt_current = Q96 * U256::from(2u64);
+        let sqrt_target = Q96;
+        let liquidity = U256::from(100u64); // very small liquidity
+        let amount_remaining = I256::from(1_000_000_000i64); // large amount
+        let fee_pips = U256::from(3000u64);
+
+        let result = compute_swap_step(
+            sqrt_current,
+            sqrt_target,
+            liquidity,
+            amount_remaining,
+            fee_pips,
+        );
+
+        // Should reach the target price
+        assert_eq!(result.sqrt_ratio_next_x96, sqrt_target);
+    }
+
+    #[test]
+    fn test_zero_fee() {
+        let sqrt_current = Q96 * U256::from(2u64);
+        let sqrt_target = Q96;
+        let liquidity = U256::from(1_000_000_000_000u128);
+        let amount_remaining = I256::from(1_000_000i64);
+        let fee_pips = U256::ZERO;
+
+        let result = compute_swap_step(
+            sqrt_current,
+            sqrt_target,
+            liquidity,
+            amount_remaining,
+            fee_pips,
+        );
+
+        // With zero fee, fee_amount should be 0
+        assert_eq!(result.fee_amount, U256::ZERO);
+    }
+}