@paraswap/dex-lib 4.8.34-uni-v3-rust.2 → 4.8.35

package/native/src/lib.rs

@@ -1,528 +0,0 @@
-pub mod config;
-pub mod math;
-pub mod pool_state;
-pub mod query_outputs;
-pub mod v4_query_outputs;
-
-use ethnum::{I256, U256};
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-use rayon::prelude::*;
-use std::collections::HashMap;
-
-/// Set the number of threads rayon uses for parallel queries.
-/// Call once at startup. Defaults to all available cores if not called.
-#[napi]
-pub fn set_thread_count(n: u32) {
-    rayon::ThreadPoolBuilder::new()
-        .num_threads(n as usize)
-        .build_global()
-        .ok();
-}
-
-use config::MathVariant;
-use math::oracle::OracleObservation;
-use math::tick::TickInfo;
-use pool_state::PoolState;
-
-// ---- NAPI type definitions for JS interop ----
-
-#[napi(object)]
-pub struct JsTickEntry {
-    pub key: i32,
-    pub liquidity_gross: BigInt,
-    pub liquidity_net: BigInt,
-}
-
-#[napi(object)]
-pub struct JsBitmapEntry {
-    pub key: i32,
-    pub value: BigInt,
-}
-
-#[napi(object)]
-pub struct JsObservationEntry {
-    pub key: i32,
-    pub block_timestamp: BigInt,
-    pub tick_cumulative: BigInt,
-    pub seconds_per_liquidity_cumulative_x128: BigInt,
-    pub initialized: bool,
-}
-
-#[napi(object)]
-pub struct JsPoolStateInit {
-    pub variant: String,
-    pub bitmap_range: i32,
-    pub block_timestamp: BigInt,
-    pub tick_spacing: BigInt,
-    pub fee: BigInt,
-    pub sqrt_price_x96: BigInt,
-    pub tick: BigInt,
-    pub observation_index: i32,
-    pub observation_cardinality: i32,
-    pub observation_cardinality_next: i32,
-    pub fee_protocol: BigInt,
-    pub liquidity: BigInt,
-    pub max_liquidity_per_tick: BigInt,
-    pub start_tick_bitmap: BigInt,
-    pub lowest_known_tick: BigInt,
-    pub highest_known_tick: BigInt,
-    pub tick_bitmap: Vec<JsBitmapEntry>,
-    pub ticks: Vec<JsTickEntry>,
-    pub observations: Vec<JsObservationEntry>,
-}
-
-#[napi(object)]
-pub struct JsOutputResult {
-    pub outputs: Vec<BigInt>,
-    pub tick_counts: Vec<i32>,
-}
-
-// ---- Conversion helpers ----
-// napi::bindgen_prelude::BigInt stores { sign_bit: bool, words: Vec<u64> }
-// words are little-endian u64 limbs.
-
-fn bigint_to_u256(bi: &BigInt) -> U256 {
-    let words = &bi.words;
-    let low = words.first().copied().unwrap_or(0) as u128
-        | (words.get(1).copied().unwrap_or(0) as u128) << 64;
-    let high = words.get(2).copied().unwrap_or(0) as u128
-        | (words.get(3).copied().unwrap_or(0) as u128) << 64;
-    U256::from_words(high, low)
-}
-
-fn bigint_to_i256(bi: &BigInt) -> I256 {
-    let u = bigint_to_u256(bi);
-    let val = u.as_i256();
-    if bi.sign_bit {
-        -val
-    } else {
-        val
-    }
-}
-
-fn u256_to_bigint(val: U256) -> BigInt {
-    let (high, low) = val.into_words();
-    let mut words = vec![
-        low as u64,
-        (low >> 64) as u64,
-        high as u64,
-        (high >> 64) as u64,
-    ];
-    // Trim trailing zeros for cleaner representation
-    while words.len() > 1 && *words.last().unwrap() == 0 {
-        words.pop();
-    }
-    BigInt {
-        sign_bit: false,
-        words,
-    }
-}
-
-// ---- The main NAPI class ----
-
-#[napi]
-pub struct RustPoolHandle {
-    state: PoolState,
-}
-
-#[napi]
-impl RustPoolHandle {
-    /// Create a new Rust-owned pool state from JS data.
-    #[napi(factory)]
-    pub fn create(init: JsPoolStateInit) -> Result<Self> {
-        let variant = MathVariant::from_str(&init.variant);
-
-        let mut tick_bitmap = HashMap::with_capacity(init.tick_bitmap.len());
-        for entry in &init.tick_bitmap {
-            tick_bitmap.insert(entry.key as i16, bigint_to_u256(&entry.value));
-        }
-
-        let mut ticks = HashMap::with_capacity(init.ticks.len());
-        for entry in &init.ticks {
-            ticks.insert(
-                entry.key,
-                TickInfo {
-                    liquidity_gross: bigint_to_u256(&entry.liquidity_gross),
-                    liquidity_net: bigint_to_i256(&entry.liquidity_net),
-                    initialized: true,
-                },
-            );
-        }
-
-        let mut observations = HashMap::with_capacity(init.observations.len());
-        for entry in &init.observations {
-            observations.insert(
-                entry.key as u16,
-                OracleObservation {
-                    block_timestamp: bigint_to_u256(&entry.block_timestamp),
-                    tick_cumulative: bigint_to_i256(&entry.tick_cumulative),
-                    seconds_per_liquidity_cumulative_x128: bigint_to_u256(
-                        &entry.seconds_per_liquidity_cumulative_x128,
-                    ),
-                    initialized: entry.initialized,
-                },
-            );
-        }
-
-        let start_tick_bitmap = bigint_to_i256(&init.start_tick_bitmap);
-
-        // bitmap_range is the total half-width (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE)
-        // passed from TS since it varies per DEX and per network.
-        let start_i16 = start_tick_bitmap.as_i32() as i16;
-        let range = init.bitmap_range as i16;
-        let bitmap_range_lower = start_i16 - range;
-        let bitmap_range_upper = start_i16 + range;
-
-        Ok(Self {
-            state: PoolState {
-                block_timestamp: bigint_to_u256(&init.block_timestamp),
-                tick_spacing: bigint_to_i256(&init.tick_spacing),
-                fee: bigint_to_u256(&init.fee),
-                sqrt_price_x96: bigint_to_u256(&init.sqrt_price_x96),
-                tick: bigint_to_i256(&init.tick),
-                observation_index: init.observation_index as u16,
-                observation_cardinality: init.observation_cardinality as u16,
-                observation_cardinality_next: init.observation_cardinality_next as u16,
-                fee_protocol: bigint_to_u256(&init.fee_protocol),
-                liquidity: bigint_to_u256(&init.liquidity),
-                max_liquidity_per_tick: bigint_to_u256(&init.max_liquidity_per_tick),
-                tick_bitmap,
-                ticks,
-                observations,
-                start_tick_bitmap,
-                lowest_known_tick: bigint_to_i256(&init.lowest_known_tick),
-                highest_known_tick: bigint_to_i256(&init.highest_known_tick),
-                bitmap_range_lower,
-                bitmap_range_upper,
-                variant,
-            },
-        })
-    }
-
-    /// HOT PATH: Price N amounts in one call (BigInt version).
-    /// side: 0 = SELL, 1 = BUY
-    #[napi]
-    pub fn query_outputs(
-        &self,
-        amounts: Vec<BigInt>,
-        zero_for_one: bool,
-        side: u8,
-    ) -> Result<JsOutputResult> {
-        let amounts_u256: Vec<U256> = amounts.iter().map(|a| bigint_to_u256(a)).collect();
-
-        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-            query_outputs::query_outputs(&self.state, &amounts_u256, zero_for_one, side)
-        }));
-
-        match result {
-            Ok(output) => {
-                let outputs: Vec<BigInt> =
-                    output.outputs.iter().map(|v| u256_to_bigint(*v)).collect();
-
-                Ok(JsOutputResult {
-                    outputs,
-                    tick_counts: output.tick_counts,
-                })
-            }
-            Err(panic_info) => {
-                let msg = if let Some(s) = panic_info.downcast_ref::<&str>() {
-                    s.to_string()
-                } else if let Some(s) = panic_info.downcast_ref::<String>() {
-                    s.clone()
-                } else {
-                    "Unknown panic in query_outputs".to_string()
-                };
-                Err(Error::new(Status::GenericFailure, msg))
-            }
-        }
-    }
-
-}
-
-// ---- Pool Registry: batch parallel queries ----
-
-fn build_pool_state(init: &JsPoolStateInit) -> Result<PoolState> {
-    let variant = MathVariant::from_str(&init.variant);
-
-    let mut tick_bitmap = HashMap::with_capacity(init.tick_bitmap.len());
-    for entry in &init.tick_bitmap {
-        tick_bitmap.insert(entry.key as i16, bigint_to_u256(&entry.value));
-    }
-
-    let mut ticks = HashMap::with_capacity(init.ticks.len());
-    for entry in &init.ticks {
-        ticks.insert(
-            entry.key,
-            TickInfo {
-                liquidity_gross: bigint_to_u256(&entry.liquidity_gross),
-                liquidity_net: bigint_to_i256(&entry.liquidity_net),
-                initialized: true,
-            },
-        );
-    }
-
-    let mut observations = HashMap::with_capacity(init.observations.len());
-    for entry in &init.observations {
-        observations.insert(
-            entry.key as u16,
-            OracleObservation {
-                block_timestamp: bigint_to_u256(&entry.block_timestamp),
-                tick_cumulative: bigint_to_i256(&entry.tick_cumulative),
-                seconds_per_liquidity_cumulative_x128: bigint_to_u256(
-                    &entry.seconds_per_liquidity_cumulative_x128,
-                ),
-                initialized: entry.initialized,
-            },
-        );
-    }
-
-    let start_tick_bitmap = bigint_to_i256(&init.start_tick_bitmap);
-    let start_i16 = start_tick_bitmap.as_i32() as i16;
-    let range = init.bitmap_range as i16;
-
-    Ok(PoolState {
-        block_timestamp: bigint_to_u256(&init.block_timestamp),
-        tick_spacing: bigint_to_i256(&init.tick_spacing),
-        fee: bigint_to_u256(&init.fee),
-        sqrt_price_x96: bigint_to_u256(&init.sqrt_price_x96),
-        tick: bigint_to_i256(&init.tick),
-        observation_index: init.observation_index as u16,
-        observation_cardinality: init.observation_cardinality as u16,
-        observation_cardinality_next: init.observation_cardinality_next as u16,
-        fee_protocol: bigint_to_u256(&init.fee_protocol),
-        liquidity: bigint_to_u256(&init.liquidity),
-        max_liquidity_per_tick: bigint_to_u256(&init.max_liquidity_per_tick),
-        tick_bitmap,
-        ticks,
-        observations,
-        start_tick_bitmap,
-        lowest_known_tick: bigint_to_i256(&init.lowest_known_tick),
-        highest_known_tick: bigint_to_i256(&init.highest_known_tick),
-        bitmap_range_lower: start_i16 - range,
-        bitmap_range_upper: start_i16 + range,
-        variant,
-    })
-}
-
-#[napi(object)]
-pub struct JsPoolQueryResult {
-    pub key: String,
-    pub outputs: Vec<BigInt>,
-    pub tick_counts: Vec<i32>,
-}
-
-#[napi]
-pub struct RustPoolRegistry {
-    pools: HashMap<String, PoolState>,
-}
-
-#[napi]
-impl RustPoolRegistry {
-    #[napi(constructor)]
-    pub fn new() -> Self {
-        Self {
-            pools: HashMap::new(),
-        }
-    }
-
-    /// Register or update a pool.
-    #[napi]
-    pub fn set_pool(&mut self, key: String, init: JsPoolStateInit) -> Result<()> {
-        let state = build_pool_state(&init)?;
-        self.pools.insert(key, state);
-        Ok(())
-    }
-
-    /// Remove a pool.
-    #[napi]
-    pub fn remove_pool(&mut self, key: String) {
-        self.pools.remove(&key);
-    }
-
-    /// Query multiple pools in parallel. Returns results for all registered pools
-    /// whose keys are in the provided list.
-    /// Each pool is queried with the SAME amounts and direction.
-    #[napi]
-    pub fn query_many(
-        &self,
-        keys: Vec<String>,
-        amounts: Vec<BigInt>,
-        zero_for_one: bool,
-        side: u8,
-    ) -> Result<Vec<JsPoolQueryResult>> {
-        let amounts_u256: Vec<U256> = amounts.iter().map(|a| bigint_to_u256(a)).collect();
-
-        // Collect references to pools that exist
-        let pool_refs: Vec<(&str, &PoolState)> = keys
-            .iter()
-            .filter_map(|k| self.pools.get(k).map(|p| (k.as_str(), p)))
-            .collect();
-
-        // Run all pool queries in parallel using rayon
-        let results: Vec<Result<JsPoolQueryResult>> = pool_refs
-            .par_iter()
-            .map(|(key, pool)| {
-                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    query_outputs::query_outputs(pool, &amounts_u256, zero_for_one, side)
-                }));
-
-                match result {
-                    Ok(output) => {
-                        let outputs: Vec<BigInt> =
-                            output.outputs.iter().map(|v| u256_to_bigint(*v)).collect();
-                        Ok(JsPoolQueryResult {
-                            key: key.to_string(),
-                            outputs,
-                            tick_counts: output.tick_counts,
-                        })
-                    }
-                    Err(_) => Ok(JsPoolQueryResult {
-                        key: key.to_string(),
-                        outputs: vec![],
-                        tick_counts: vec![],
-                    }),
-                }
-            })
-            .collect();
-
-        results.into_iter().collect()
-    }
-
-    #[napi]
-    pub fn pool_count(&self) -> u32 {
-        self.pools.len() as u32
-    }
-}
-
-// ---- V4 Pool Registry ----
-
-#[napi(object)]
-pub struct JsV4PoolStateInit {
-    pub sqrt_price_x96: BigInt,
-    pub tick: BigInt,
-    pub protocol_fee: BigInt,
-    pub lp_fee: BigInt,
-    pub liquidity: BigInt,
-    pub tick_spacing: BigInt,
-    pub fee_growth_global0_x128: BigInt,
-    pub fee_growth_global1_x128: BigInt,
-    pub bitmap_range: i32,
-    pub start_tick_bitmap: BigInt,
-    pub tick_bitmap: Vec<JsBitmapEntry>,
-    pub ticks: Vec<JsTickEntry>,
-}
-
-#[napi(object)]
-pub struct JsV4QueryResult {
-    pub key: String,
-    pub outputs: Vec<BigInt>,
-}
-
-fn build_v4_pool_state(init: &JsV4PoolStateInit) -> v4_query_outputs::V4PoolState {
-    let mut tick_bitmap = HashMap::with_capacity(init.tick_bitmap.len());
-    for entry in &init.tick_bitmap {
-        tick_bitmap.insert(entry.key as i16, bigint_to_u256(&entry.value));
-    }
-
-    let mut ticks = HashMap::with_capacity(init.ticks.len());
-    for entry in &init.ticks {
-        ticks.insert(
-            entry.key,
-            TickInfo {
-                liquidity_gross: bigint_to_u256(&entry.liquidity_gross),
-                liquidity_net: bigint_to_i256(&entry.liquidity_net),
-                initialized: true,
-            },
-        );
-    }
-
-    v4_query_outputs::V4PoolState {
-        sqrt_price_x96: bigint_to_u256(&init.sqrt_price_x96),
-        tick: bigint_to_i256(&init.tick),
-        protocol_fee: bigint_to_u256(&init.protocol_fee),
-        lp_fee: bigint_to_u256(&init.lp_fee),
-        liquidity: bigint_to_u256(&init.liquidity),
-        tick_spacing: bigint_to_i256(&init.tick_spacing),
-        fee_growth_global0_x128: bigint_to_u256(&init.fee_growth_global0_x128),
-        fee_growth_global1_x128: bigint_to_u256(&init.fee_growth_global1_x128),
-        tick_bitmap,
-        ticks,
-    }
-}
-
-#[napi]
-pub struct RustV4PoolRegistry {
-    pools: HashMap<String, (v4_query_outputs::V4PoolState, I256)>, // state + tickSpacing
-}
-
-#[napi]
-impl RustV4PoolRegistry {
-    #[napi(constructor)]
-    pub fn new() -> Self {
-        Self {
-            pools: HashMap::new(),
-        }
-    }
-
-    #[napi]
-    pub fn set_pool(&mut self, key: String, init: JsV4PoolStateInit) {
-        let tick_spacing = bigint_to_i256(&init.tick_spacing);
-        let state = build_v4_pool_state(&init);
-        self.pools.insert(key, (state, tick_spacing));
-    }
-
-    #[napi]
-    pub fn remove_pool(&mut self, key: String) {
-        self.pools.remove(&key);
-    }
-
-    #[napi]
-    pub fn query_many(
-        &self,
-        keys: Vec<String>,
-        amounts: Vec<BigInt>,
-        zero_for_one: bool,
-        side: u8,
-    ) -> Vec<JsV4QueryResult> {
-        let amounts_u256: Vec<U256> = amounts.iter().map(|a| bigint_to_u256(a)).collect();
-
-        let pool_refs: Vec<(&str, &v4_query_outputs::V4PoolState, I256)> = keys
-            .iter()
-            .filter_map(|k| {
-                self.pools
-                    .get(k)
-                    .map(|(p, ts)| (k.as_str(), p, *ts))
-            })
-            .collect();
-
-        pool_refs
-            .par_iter()
-            .map(|(key, pool, tick_spacing)| {
-                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    v4_query_outputs::query_outputs(pool, *tick_spacing, &amounts_u256, zero_for_one, side)
-                }));
-
-                match result {
-                    Ok(outputs) => {
-                        let bigint_outputs: Vec<BigInt> =
-                            outputs.iter().map(|v| u256_to_bigint(*v)).collect();
-                        JsV4QueryResult {
-                            key: key.to_string(),
-                            outputs: bigint_outputs,
-                        }
-                    }
-                    Err(_) => JsV4QueryResult {
-                        key: key.to_string(),
-                        outputs: vec![],
-                    },
-                }
-            })
-            .collect()
-    }
-
-    #[napi]
-    pub fn pool_count(&self) -> u32 {
-        self.pools.len() as u32
-    }
-}

package/native/src/math/bit_math.rs

@@ -1,177 +0,0 @@
-use ethnum::U256;
-
-/// Returns the index of the most significant bit of the number,
-/// where the least significant bit is at index 0 and the most significant bit is at index 255.
-///
-/// Panics if x is zero.
-pub fn most_significant_bit(x: U256) -> u8 {
-    assert!(x > U256::ZERO, "x must be > 0");
-    let mut x = x;
-    let mut r: u8 = 0;
-
-    if x >= U256::from_words(1, 0) {
-        x >>= 128;
-        r += 128;
-    }
-    if x >= U256::from(0x10000000000000000u128) {
-        x >>= 64;
-        r += 64;
-    }
-    if x >= U256::from(0x100000000u128) {
-        x >>= 32;
-        r += 32;
-    }
-    if x >= U256::from(0x10000u64) {
-        x >>= 16;
-        r += 16;
-    }
-    if x >= U256::from(0x100u64) {
-        x >>= 8;
-        r += 8;
-    }
-    if x >= U256::from(0x10u64) {
-        x >>= 4;
-        r += 4;
-    }
-    if x >= U256::from(0x4u64) {
-        x >>= 2;
-        r += 2;
-    }
-    if x >= U256::from(0x2u64) {
-        r += 1;
-    }
-
-    r
-}
-
-/// Returns the index of the least significant bit of the number,
-/// where the least significant bit is at index 0 and the most significant bit is at index 255.
-///
-/// Panics if x is zero.
-pub fn least_significant_bit(x: U256) -> u8 {
-    assert!(x > U256::ZERO, "x must be > 0");
-    let mut x = x;
-    let mut r: u8 = 255;
-
-    let max_uint128: U256 = U256::new(u128::MAX);
-    let max_uint64: U256 = U256::from(u64::MAX);
-    let max_uint32: U256 = U256::from(u32::MAX as u64);
-    let max_uint16: U256 = U256::from(u16::MAX as u64);
-    let max_uint8: U256 = U256::from(u8::MAX as u64);
-
-    if (x & max_uint128) > U256::ZERO {
-        r -= 128;
-    } else {
-        x >>= 128;
-    }
-    if (x & max_uint64) > U256::ZERO {
-        r -= 64;
-    } else {
-        x >>= 64;
-    }
-    if (x & max_uint32) > U256::ZERO {
-        r -= 32;
-    } else {
-        x >>= 32;
-    }
-    if (x & max_uint16) > U256::ZERO {
-        r -= 16;
-    } else {
-        x >>= 16;
-    }
-    if (x & max_uint8) > U256::ZERO {
-        r -= 8;
-    } else {
-        x >>= 8;
-    }
-    if (x & U256::from(0xFu64)) > U256::ZERO {
-        r -= 4;
-    } else {
-        x >>= 4;
-    }
-    if (x & U256::from(0x3u64)) > U256::ZERO {
-        r -= 2;
-    } else {
-        x >>= 2;
-    }
-    if (x & U256::ONE) > U256::ZERO {
-        r -= 1;
-    }
-
-    r
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_msb_one() {
-        assert_eq!(most_significant_bit(U256::ONE), 0);
-    }
-
-    #[test]
-    fn test_msb_two() {
-        assert_eq!(most_significant_bit(U256::from(2u64)), 1);
-    }
-
-    #[test]
-    fn test_msb_powers_of_two() {
-        for i in 0..=255u8 {
-            let x = U256::ONE << i;
-            assert_eq!(most_significant_bit(x), i);
-        }
-    }
-
-    #[test]
-    fn test_msb_max() {
-        assert_eq!(most_significant_bit(U256::MAX), 255);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_msb_zero_panics() {
-        most_significant_bit(U256::ZERO);
-    }
-
-    #[test]
-    fn test_lsb_one() {
-        assert_eq!(least_significant_bit(U256::ONE), 0);
-    }
-
-    #[test]
-    fn test_lsb_two() {
-        assert_eq!(least_significant_bit(U256::from(2u64)), 1);
-    }
-
-    #[test]
-    fn test_lsb_powers_of_two() {
-        for i in 0..=255u8 {
-            let x = U256::ONE << i;
-            assert_eq!(least_significant_bit(x), i);
-        }
-    }
-
-    #[test]
-    fn test_lsb_max() {
-        assert_eq!(least_significant_bit(U256::MAX), 0);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_lsb_zero_panics() {
-        least_significant_bit(U256::ZERO);
-    }
-
-    #[test]
-    fn test_msb_mixed() {
-        assert_eq!(most_significant_bit(U256::from(10u64)), 3);
-        assert_eq!(most_significant_bit(U256::from(24u64)), 4);
-    }
-
-    #[test]
-    fn test_lsb_mixed() {
-        assert_eq!(least_significant_bit(U256::from(10u64)), 1);
-        assert_eq!(least_significant_bit(U256::from(24u64)), 3);
-    }
-}