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

package/native/src/query_outputs.rs

@@ -1,379 +0,0 @@
-use ethnum::{I256, U256};
-use std::collections::HashMap;
-
-use crate::math::liquidity_math;
-use crate::math::oracle;
-use crate::math::swap_math;
-use crate::math::tick;
-use crate::math::tick::TickInfo;
-use crate::math::tick_bitmap;
-use crate::math::tick_math;
-use crate::pool_state::PoolState;
-
-const MAX_PRICING_COMPUTATION_STEPS_ALLOWED: i32 = 128;
-
-/// 0 = SELL, 1 = BUY (matches SwapSide enum in TS)
-pub const SWAP_SIDE_SELL: u8 = 0;
-
-pub struct OutputResult {
-    pub outputs: Vec<U256>,
-    pub tick_counts: Vec<i32>,
-}
-
-#[derive(Clone)]
-struct PriceComputationState {
-    amount_specified_remaining: I256,
-    amount_calculated: I256,
-    sqrt_price_x96: U256,
-    tick: I256,
-    protocol_fee: U256,
-    liquidity: U256,
-    is_first_cycle_state: bool,
-}
-
-#[derive(Clone)]
-struct PriceComputationCache {
-    liquidity_start: U256,
-    block_timestamp: U256,
-    fee_protocol: U256,
-    seconds_per_liquidity_cumulative_x128: U256,
-    tick_cumulative: I256,
-    computed_latest_observation: bool,
-    tick_count: i32,
-}
-
-struct Slot0Snapshot {
-    sqrt_price_x96: U256,
-    tick: I256,
-    observation_index: u16,
-    observation_cardinality: u16,
-}
-
-fn price_computation_cycles(
-    pool: &PoolState,
-    ticks_copy: &mut HashMap<i32, TickInfo>,
-    slot0_start: &Slot0Snapshot,
-    state: &mut PriceComputationState,
-    cache: &mut PriceComputationCache,
-    sqrt_price_limit_x96: U256,
-    zero_for_one: bool,
-    exact_input: bool,
-    is_sell: bool,
-) -> (PriceComputationState, PriceComputationCache) {
-    let mut latest_full_cycle_state = state.clone();
-
-    if cache.tick_count == 0 {
-        cache.tick_count = 1;
-    }
-    let mut latest_full_cycle_cache = cache.clone();
-
-    let mut last_ticks_copy: Option<(i32, TickInfo)> = None;
-
-    let mut i: i32 = 0;
-    while state.amount_specified_remaining != I256::ZERO
-        && state.sqrt_price_x96 != sqrt_price_limit_x96
-    {
-        if latest_full_cycle_cache.tick_count + i > MAX_PRICING_COMPUTATION_STEPS_ALLOWED {
-            state.amount_specified_remaining = I256::ZERO;
-            state.amount_calculated = I256::ZERO;
-            break;
-        }
-
-        let sqrt_price_start_x96 = state.sqrt_price_x96;
-
-        // Find next initialized tick — returns Err if out of bitmap range
-        let bitmap_result = tick_bitmap::next_initialized_tick_within_one_word(
-            &pool.tick_bitmap,
-            state.tick,
-            pool.tick_spacing,
-            zero_for_one,
-            true, // is_price_query
-            Some((pool.bitmap_range_lower, pool.bitmap_range_upper)),
-        );
-
-        let (tick_next_raw, initialized) = match bitmap_result {
-            Ok(result) => result,
-            Err(_) => {
-                // Out of range — zero out remaining
-                state.amount_specified_remaining = I256::ZERO;
-                state.amount_calculated = I256::ZERO;
-                break;
-            }
-        };
-
-        // Clamp to min/max tick
-        let tick_next = if tick_next_raw < tick_math::MIN_TICK {
-            tick_math::MIN_TICK
-        } else if tick_next_raw > tick_math::MAX_TICK {
-            tick_math::MAX_TICK
-        } else {
-            tick_next_raw
-        };
-
-        let sqrt_price_next_x96 = tick_math::get_sqrt_ratio_at_tick(tick_next);
-
-        // Determine target price (clamped by limit)
-        let sqrt_ratio_target = if zero_for_one {
-            if sqrt_price_next_x96 < sqrt_price_limit_x96 {
-                sqrt_price_limit_x96
-            } else {
-                sqrt_price_next_x96
-            }
-        } else {
-            if sqrt_price_next_x96 > sqrt_price_limit_x96 {
-                sqrt_price_limit_x96
-            } else {
-                sqrt_price_next_x96
-            }
-        };
-
-        let step_result = swap_math::compute_swap_step(
-            state.sqrt_price_x96,
-            sqrt_ratio_target,
-            state.liquidity,
-            state.amount_specified_remaining,
-            pool.fee,
-        );
-
-        state.sqrt_price_x96 = step_result.sqrt_ratio_next_x96;
-        let amount_in = step_result.amount_in;
-        let amount_out = step_result.amount_out;
-        let mut fee_amount = step_result.fee_amount;
-
-        if exact_input {
-            state.amount_specified_remaining -=
-                amount_in.as_i256() + fee_amount.as_i256();
-            state.amount_calculated -= amount_out.as_i256();
-        } else {
-            state.amount_specified_remaining += amount_out.as_i256();
-            state.amount_calculated +=
-                amount_in.as_i256() + fee_amount.as_i256();
-        }
-
-        if cache.fee_protocol > U256::ZERO {
-            let delta = pool.variant.protocol_fee_delta(fee_amount, cache.fee_protocol);
-            fee_amount -= delta;
-            state.protocol_fee += delta;
-        }
-
-        if state.sqrt_price_x96 == sqrt_price_next_x96 {
-            if initialized {
-                if pool.variant.has_oracle() && !cache.computed_latest_observation {
-                    let (tc, splc) = oracle::observe_single(
-                        &pool.observations,
-                        cache.block_timestamp,
-                        U256::ZERO,
-                        pool.block_timestamp,
-                        slot0_start.tick,
-                        slot0_start.observation_index,
-                        cache.liquidity_start,
-                        slot0_start.observation_cardinality,
-                    );
-                    cache.tick_cumulative = tc;
-                    cache.seconds_per_liquidity_cumulative_x128 = splc;
-                    cache.computed_latest_observation = true;
-                }
-
-                if state.amount_specified_remaining == I256::ZERO {
-                    let tick_idx = tick_next.as_i32();
-                    if let Some(existing) = ticks_copy.get(&tick_idx) {
-                        last_ticks_copy = Some((tick_idx, existing.clone()));
-                    }
-                }
-
-                let mut liquidity_net = tick::cross(ticks_copy, tick_next.as_i32());
-                if zero_for_one {
-                    liquidity_net = -liquidity_net;
-                }
-
-                state.liquidity = liquidity_math::add_delta(state.liquidity, liquidity_net);
-            }
-
-            state.tick = if zero_for_one {
-                tick_next - I256::ONE
-            } else {
-                tick_next
-            };
-        } else if state.sqrt_price_x96 != sqrt_price_start_x96 {
-            state.tick = tick_math::get_tick_at_sqrt_ratio(state.sqrt_price_x96);
-        }
-
-        if state.amount_specified_remaining != I256::ZERO {
-            latest_full_cycle_state = state.clone();
-            latest_full_cycle_cache = cache.clone();
-        } else if let Some((idx, tick_info)) = last_ticks_copy.take() {
-            ticks_copy.insert(idx, tick_info);
-        }
-
-        i += 1;
-    }
-
-    if i > 1 {
-        latest_full_cycle_cache.tick_count += i - 1;
-    }
-
-    if state.amount_specified_remaining != I256::ZERO
-        && (!is_sell || pool.variant.zero_remaining_for_sell())
-    {
-        state.amount_specified_remaining = I256::ZERO;
-        state.amount_calculated = I256::ZERO;
-    }
-
-    (latest_full_cycle_state, latest_full_cycle_cache)
-}
-
-/// Main pricing entry point. Equivalent to UniswapV3Math.queryOutputs() in TS.
-pub fn query_outputs(
-    pool: &PoolState,
-    amounts: &[U256],
-    zero_for_one: bool,
-    side: u8,
-) -> OutputResult {
-    let is_sell = side == SWAP_SIDE_SELL;
-
-    let slot0_start = Slot0Snapshot {
-        sqrt_price_x96: pool.sqrt_price_x96,
-        tick: pool.tick,
-        observation_index: pool.observation_index,
-        observation_cardinality: pool.observation_cardinality,
-    };
-
-    let sqrt_price_limit_x96 = if zero_for_one {
-        tick_math::MIN_SQRT_RATIO + U256::ONE
-    } else {
-        tick_math::MAX_SQRT_RATIO - U256::ONE
-    };
-
-    let fee_protocol = pool.variant.fee_protocol(pool.fee_protocol, zero_for_one);
-
-    let mut cache = PriceComputationCache {
-        liquidity_start: pool.liquidity,
-        block_timestamp: pool.block_timestamp & U256::from(0xFFFFFFFFu32),
-        fee_protocol,
-        seconds_per_liquidity_cumulative_x128: U256::ZERO,
-        tick_cumulative: I256::ZERO,
-        computed_latest_observation: false,
-        tick_count: 0,
-    };
-
-    let mut state = PriceComputationState {
-        amount_specified_remaining: I256::ZERO,
-        amount_calculated: I256::ZERO,
-        sqrt_price_x96: slot0_start.sqrt_price_x96,
-        tick: slot0_start.tick,
-        protocol_fee: U256::ZERO,
-        liquidity: cache.liquidity_start,
-        is_first_cycle_state: true,
-    };
-
-    // Verify price limit
-    if zero_for_one {
-        assert!(
-            sqrt_price_limit_x96 < slot0_start.sqrt_price_x96
-                && sqrt_price_limit_x96 > tick_math::MIN_SQRT_RATIO,
-            "SPL"
-        );
-    } else {
-        assert!(
-            sqrt_price_limit_x96 > slot0_start.sqrt_price_x96
-                && sqrt_price_limit_x96 < tick_math::MAX_SQRT_RATIO,
-            "SPL"
-        );
-    }
-
-    let mut is_out_of_range = false;
-    let mut previous_amount = I256::ZERO;
-
-    let mut outputs = vec![U256::ZERO; amounts.len()];
-    let mut tick_counts = vec![0i32; amounts.len()];
-
-    // We use a mutable copy of ticks for cross() mutations during pricing
-    let mut ticks_copy = pool.ticks.clone();
-
-    for (i, &amount) in amounts.iter().enumerate() {
-        if amount == U256::ZERO {
-            outputs[i] = U256::ZERO;
-            tick_counts[i] = 0;
-            continue;
-        }
-
-        // BigInt.asIntN(256, amount) — reinterpret U256 bits as I256
-        let amount_as_i256 = amount.as_i256();
-        let amount_specified = if is_sell {
-            amount_as_i256
-        } else {
-            -amount_as_i256
-        };
-
-        if state.is_first_cycle_state {
-            state.amount_specified_remaining = amount_specified;
-            state.is_first_cycle_state = false;
-        } else {
-            state.amount_specified_remaining =
-                amount_specified - (previous_amount - state.amount_specified_remaining);
-        }
-
-        let exact_input = amount_specified > I256::ZERO;
-
-        if !is_out_of_range {
-            let (latest_full_cycle_state, latest_full_cycle_cache) = price_computation_cycles(
-                pool,
-                &mut ticks_copy,
-                &slot0_start,
-                &mut state,
-                &mut cache,
-                sqrt_price_limit_x96,
-                zero_for_one,
-                exact_input,
-                is_sell,
-            );
-
-            if state.amount_specified_remaining == I256::ZERO
-                && state.amount_calculated == I256::ZERO
-            {
-                is_out_of_range = true;
-                outputs[i] = U256::ZERO;
-                tick_counts[i] = 0;
-                continue;
-            }
-
-            previous_amount = amount_specified;
-
-            let (amount0, amount1) = if zero_for_one == exact_input {
-                (
-                    amount_specified - state.amount_specified_remaining,
-                    state.amount_calculated,
-                )
-            } else {
-                (
-                    state.amount_calculated,
-                    amount_specified - state.amount_specified_remaining,
-                )
-            };
-
-            // Restore state to latest full cycle for next amount
-            state = latest_full_cycle_state;
-            cache = latest_full_cycle_cache;
-
-            if is_sell {
-                // output = BigInt.asUintN(256, -(zeroForOne ? amount1 : amount0))
-                let neg = -(if zero_for_one { amount1 } else { amount0 });
-                outputs[i] = neg.as_u256();
-                tick_counts[i] = cache.tick_count;
-            } else {
-                // output = BigInt.asUintN(256, zeroForOne ? amount0 : amount1)
-                let val = if zero_for_one { amount0 } else { amount1 };
-                outputs[i] = val.as_u256();
-                tick_counts[i] = cache.tick_count;
-            }
-        } else {
-            outputs[i] = U256::ZERO;
-            tick_counts[i] = 0;
-        }
-    }
-
-    OutputResult {
-        outputs,
-        tick_counts,
-    }
-}

package/native/src/v4_query_outputs.rs

@@ -1,255 +0,0 @@
-use ethnum::{I256, U256};
-use std::collections::HashMap;
-
-use crate::math::liquidity_math;
-use crate::math::swap_math;
-use crate::math::tick;
-use crate::math::tick::TickInfo;
-use crate::math::tick_bitmap;
-use crate::math::tick_math;
-
-const MAX_PRICING_COMPUTATION_STEPS_ALLOWED: i32 = 64;
-const PIPS_DENOMINATOR: U256 = U256::new(1_000_000);
-
-/// V4 pool state — simplified vs V3 (no oracle, different fee model).
-#[derive(Debug, Clone)]
-pub struct V4PoolState {
-    pub sqrt_price_x96: U256,
-    pub tick: I256,
-    pub protocol_fee: U256,
-    pub lp_fee: U256,
-    pub liquidity: U256,
-    pub tick_spacing: I256,
-    pub fee_growth_global0_x128: U256,
-    pub fee_growth_global1_x128: U256,
-    pub tick_bitmap: HashMap<i16, U256>,
-    pub ticks: HashMap<i32, TickInfo>,
-}
-
-// --- ProtocolFeeLibrary ---
-
-fn get_zero_for_one_fee(protocol_fee: U256) -> U256 {
-    protocol_fee % U256::new(4096) // lower 12 bits
-}
-
-fn get_one_for_zero_fee(protocol_fee: U256) -> U256 {
-    protocol_fee >> 12
-}
-
-fn calculate_swap_fee(protocol_fee: U256, lp_fee: U256) -> U256 {
-    // protocolFee + lpFee - (protocolFee * lpFee) / PIPS_DENOMINATOR
-    protocol_fee + lp_fee - (protocol_fee * lp_fee) / PIPS_DENOMINATOR
-}
-
-// --- SwapMath helpers ---
-
-fn get_sqrt_price_target(zero_for_one: bool, next_price: U256, limit_price: U256) -> U256 {
-    let cond = if zero_for_one {
-        next_price < limit_price
-    } else {
-        next_price > limit_price
-    };
-    if cond { limit_price } else { next_price }
-}
-
-/// V4 _swap — single amount, returns (amount0, amount1) as I256.
-fn swap(
-    pool: &V4PoolState,
-    zero_for_one: bool,
-    amount_specified: I256,
-    sqrt_price_limit_x96: U256,
-    tick_spacing: I256,
-) -> (I256, I256) {
-    let protocol_fee = if zero_for_one {
-        get_zero_for_one_fee(pool.protocol_fee)
-    } else {
-        get_one_for_zero_fee(pool.protocol_fee)
-    };
-
-    let swap_fee = if protocol_fee == U256::ZERO {
-        pool.lp_fee
-    } else {
-        calculate_swap_fee(protocol_fee, pool.lp_fee)
-    };
-
-    // MAX_SWAP_FEE check
-    if swap_fee >= U256::new(1_000_000) {
-        assert!(amount_specified < I256::ZERO, "Invalid fee for exact out");
-    }
-
-    if amount_specified == I256::ZERO {
-        return (I256::ZERO, I256::ZERO);
-    }
-
-    // SPL checks
-    if zero_for_one {
-        assert!(sqrt_price_limit_x96 < pool.sqrt_price_x96, "Price limit already exceeded");
-        assert!(sqrt_price_limit_x96 > tick_math::MIN_SQRT_RATIO, "Price limit out of bounds");
-    } else {
-        assert!(sqrt_price_limit_x96 > pool.sqrt_price_x96, "Price limit already exceeded");
-        assert!(sqrt_price_limit_x96 < tick_math::MAX_SQRT_RATIO, "Price limit out of bounds");
-    }
-
-    let mut amount_remaining = amount_specified;
-    let mut amount_calculated = I256::ZERO;
-    let mut sqrt_price_x96 = pool.sqrt_price_x96;
-    let mut current_tick = pool.tick;
-    let mut liquidity = pool.liquidity;
-
-    let mut counter = 0i32;
-    while !(amount_remaining == I256::ZERO || sqrt_price_x96 == sqrt_price_limit_x96)
-        && counter <= MAX_PRICING_COMPUTATION_STEPS_ALLOWED
-    {
-        // Find next tick
-        // V4 has no bitmap range check — it reads through empty words naturally.
-        let (tick_next_raw, initialized) = tick_bitmap::next_initialized_tick_within_one_word(
-            &pool.tick_bitmap,
-            current_tick,
-            tick_spacing,
-            zero_for_one,
-            false, // not a bounded price query
-            None,  // no bitmap range bounds for V4
-        ).unwrap();
-
-        let tick_next = if tick_next_raw <= tick_math::MIN_TICK {
-            tick_math::MIN_TICK
-        } else if tick_next_raw >= tick_math::MAX_TICK {
-            tick_math::MAX_TICK
-        } else {
-            tick_next_raw
-        };
-
-        let sqrt_price_next_x96 = tick_math::get_sqrt_ratio_at_tick(tick_next);
-
-        let step_start_price = sqrt_price_x96;
-        let target = get_sqrt_price_target(zero_for_one, sqrt_price_next_x96, sqrt_price_limit_x96);
-
-        // V4 uses opposite sign convention: negative = exactIn.
-        // V3's compute_swap_step expects positive = exactIn.
-        // Negate before calling, results (amountIn/amountOut) stay positive.
-        let step = swap_math::compute_swap_step(
-            sqrt_price_x96,
-            target,
-            liquidity,
-            -amount_remaining,
-            swap_fee,
-        );
-
-        sqrt_price_x96 = step.sqrt_ratio_next_x96;
-
-        // V4 sign convention: amountSpecified > 0 = exactOut, < 0 = exactIn
-        if amount_specified > I256::ZERO {
-            // exactOut
-            amount_remaining -= step.amount_out.as_i256();
-            amount_calculated -= step.amount_in.as_i256() + step.fee_amount.as_i256();
-        } else {
-            // exactIn
-            amount_remaining += step.amount_in.as_i256() + step.fee_amount.as_i256();
-            amount_calculated += step.amount_out.as_i256();
-        }
-
-        if sqrt_price_x96 == sqrt_price_next_x96 {
-            if initialized {
-                let mut liquidity_net = tick::cross(&pool.ticks, tick_next.as_i32());
-                if zero_for_one {
-                    liquidity_net = -liquidity_net;
-                }
-                liquidity = liquidity_math::add_delta(liquidity, liquidity_net);
-            }
-            current_tick = if zero_for_one { tick_next - I256::ONE } else { tick_next };
-        } else if sqrt_price_x96 != step_start_price {
-            current_tick = tick_math::get_tick_at_sqrt_ratio(sqrt_price_x96);
-        }
-
-        counter += 1;
-    }
-
-    if counter >= MAX_PRICING_COMPUTATION_STEPS_ALLOWED {
-        return (I256::ZERO, I256::ZERO);
-    }
-
-    if zero_for_one != (amount_specified < I256::ZERO) {
-        (
-            amount_calculated,
-            amount_specified - amount_remaining,
-        )
-    } else {
-        (
-            amount_specified - amount_remaining,
-            amount_calculated,
-        )
-    }
-}
-
-/// V4 queryOutputs — processes each amount independently.
-/// Returns outputs as U256 (absolute values).
-pub fn query_outputs(
-    pool: &V4PoolState,
-    tick_spacing: I256,
-    amounts: &[U256],
-    zero_for_one: bool,
-    side: u8, // 0=SELL, 1=BUY
-) -> Vec<U256> {
-    let is_sell = side == 0;
-
-    amounts
-        .iter()
-        .map(|&amount| {
-            if amount == U256::ZERO {
-                return U256::ZERO;
-            }
-
-            let sqrt_price_limit_x96 = if zero_for_one {
-                tick_math::MIN_SQRT_RATIO + U256::ONE
-            } else {
-                tick_math::MAX_SQRT_RATIO - U256::ONE
-            };
-
-            if is_sell {
-                let amount_specified = -(amount.as_i256()); // exactIn: negative
-                let (amount0, amount1) = swap(
-                    pool,
-                    zero_for_one,
-                    amount_specified,
-                    sqrt_price_limit_x96,
-                    tick_spacing,
-                );
-
-                let amount_specified_actual = if zero_for_one == (amount_specified < I256::ZERO) {
-                    amount0
-                } else {
-                    amount1
-                };
-
-                if amount_specified_actual != amount_specified {
-                    return U256::ZERO;
-                }
-
-                let output = if zero_for_one { amount1 } else { amount0 };
-                output.as_u256()
-            } else {
-                let amount_specified = amount.as_i256(); // exactOut: positive
-                let (amount0, amount1) = swap(
-                    pool,
-                    zero_for_one,
-                    amount_specified,
-                    sqrt_price_limit_x96,
-                    tick_spacing,
-                );
-
-                let amount_specified_actual = if zero_for_one == (amount_specified < I256::ZERO) {
-                    amount0
-                } else {
-                    amount1
-                };
-
-                if amount_specified_actual != amount_specified {
-                    return U256::ZERO;
-                }
-
-                let output = if zero_for_one { -amount0 } else { -amount1 };
-                output.as_u256()
-            }
-        })
-        .collect()
-}