@paraswap/dex-lib 4.8.27 → 4.8.28-uni-v3-rust.1

package/native/package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "@paraswap/v3-math-native",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@paraswap/v3-math-native",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@napi-rs/cli": "^2.18.0"
+      }
+    },
+    "node_modules/@napi-rs/cli": {
+      "version": "2.18.4",
+      "resolved": "https://registry.npmjs.org/@napi-rs/cli/-/cli-2.18.4.tgz",
+      "integrity": "sha512-SgJeA4df9DE2iAEpr3M2H0OKl/yjtg1BnRI5/JyowS71tUWhrfSu2LT0V3vlHET+g1hBVlrO60PmEXwUEKp8Mg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "napi": "scripts/index.js"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    }
+  }
+}

package/native/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@paraswap/v3-math-native",
+  "version": "0.1.0",
+  "private": true,
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "v3-math-native",
+    "triples": {
+      "defaults": true
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  }
+}

package/native/src/config.rs

@@ -0,0 +1,40 @@
+/// Configures math variant differences between Uniswap V3 forks.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MathVariant {
+    /// Standard Uniswap V3: feeProtocol is 4-bit (% 16 / >> 4)
+    UniswapV3,
+    /// PancakeSwap V3: feeProtocol is 16-bit (% 65536 / >> 16), protocol_fee = feeAmount * fp / 10000
+    PancakeSwapV3,
+    /// Solidly V3: No oracle, fee from slot0.fee directly
+    SolidlyV3,
+}
+
+impl MathVariant {
+    pub fn from_str(s: &str) -> Self {
+        match s {
+            "pancakeswap_v3" => MathVariant::PancakeSwapV3,
+            "solidly_v3" => MathVariant::SolidlyV3,
+            _ => MathVariant::UniswapV3,
+        }
+    }
+
+    /// Extract the fee protocol value for the given swap direction.
+    pub fn fee_protocol(&self, fee_protocol_raw: ethnum::U256, zero_for_one: bool) -> ethnum::U256 {
+        match self {
+            MathVariant::UniswapV3 | MathVariant::SolidlyV3 => {
+                if zero_for_one {
+                    fee_protocol_raw % ethnum::U256::from(16u32)
+                } else {
+                    fee_protocol_raw >> 4
+                }
+            }
+            MathVariant::PancakeSwapV3 => {
+                if zero_for_one {
+                    fee_protocol_raw % ethnum::U256::from(65536u32)
+                } else {
+                    fee_protocol_raw >> 16
+                }
+            }
+        }
+    }
+}

package/native/src/lib.rs

@@ -0,0 +1,216 @@
+pub mod config;
+pub mod math;
+pub mod pool_state;
+pub mod query_outputs;
+
+use ethnum::{I256, U256};
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::collections::HashMap;
+
+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 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,
+                },
+            );
+        }
+
+        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: bigint_to_i256(&init.start_tick_bitmap),
+                lowest_known_tick: bigint_to_i256(&init.lowest_known_tick),
+                highest_known_tick: bigint_to_i256(&init.highest_known_tick),
+                variant,
+            },
+        })
+    }
+
+    /// HOT PATH: Price N amounts in one call.
+    /// 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))
+            }
+        }
+    }
+}

package/native/src/math/bit_math.rs

@@ -0,0 +1,177 @@
+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);
+    }
+}

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);
+    }
+}