@alcorexchange/alcor-swap-sdk 1.0.402 → 1.0.403

package/build/entities/pool.js

@@ -202,48 +202,65 @@ let Pool = exports.Pool = /*#__PURE__*/function () {
 
       // Убираем проверки invariant в продакшене, если данные гарантированно валидны
       const exactInput = amountSpecified >= _internalConstants.ZERO;
-      const state = {
-        amountSpecifiedRemaining: amountSpecified,
-        amountCalculated: _internalConstants.ZERO,
-        sqrtPriceX64: this.sqrtPriceX64,
-        tick: this.tickCurrent,
-        liquidity: this.liquidity
-      };
-      while (state.amountSpecifiedRemaining !== _internalConstants.ZERO && state.sqrtPriceX64 !== sqrtPriceLimit) {
-        const step = {
-          sqrtPriceStartX64: state.sqrtPriceX64
-        };
 
-        // Оптимизация вызова nextInitializedTickWithinOneWord
-        [step.tickNext, step.initialized] = this.tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, this.tickSpacing);
-        step.tickNext = Math.max(_tickMath.TickMath.MIN_TICK, Math.min(step.tickNext, _tickMath.TickMath.MAX_TICK));
-        step.sqrtPriceNextX64 = _tickMath.TickMath.getSqrtRatioAtTick(step.tickNext);
-        const targetPrice = (zeroForOne ? step.sqrtPriceNextX64 < sqrtPriceLimit : step.sqrtPriceNextX64 > sqrtPriceLimit) ? sqrtPriceLimit : step.sqrtPriceNextX64;
-        [state.sqrtPriceX64, step.amountIn, step.amountOut, step.feeAmount] = _swapMath.SwapMath.computeSwapStep(state.sqrtPriceX64, targetPrice, state.liquidity, state.amountSpecifiedRemaining, this.fee);
+      // Cache tickSpacing to avoid getter call each iteration
+      const tickSpacing = this.tickSpacing;
+
+      // Reset cursor for sequential tick access optimization
+      const provider = this.tickDataProvider;
+      const useCursor = typeof provider.nextInitializedTickWithinOneWordWithCursor === 'function';
+      if (useCursor) provider.resetCursor();
+
+      // State variables
+      let amountSpecifiedRemaining = amountSpecified;
+      let amountCalculated = _internalConstants.ZERO;
+      let sqrtPriceX64 = this.sqrtPriceX64;
+      let tick = this.tickCurrent;
+      let liquidity = this.liquidity;
+
+      // Step variables (reused each iteration - no object allocation)
+      let sqrtPriceStartX64;
+      let tickNext;
+      let initialized;
+      let sqrtPriceNextX64;
+      let amountIn;
+      let amountOut;
+      let feeAmount;
+      while (amountSpecifiedRemaining !== _internalConstants.ZERO && sqrtPriceX64 !== sqrtPriceLimit) {
+        sqrtPriceStartX64 = sqrtPriceX64;
+
+        // Use cursor-optimized version if available (O(1) vs O(log n))
+        [tickNext, initialized] = useCursor ? provider.nextInitializedTickWithinOneWordWithCursor(tick, zeroForOne, tickSpacing) : this.tickDataProvider.nextInitializedTickWithinOneWord(tick, zeroForOne, tickSpacing);
+
+        // Clamp tickNext to valid range
+        if (tickNext < _tickMath.TickMath.MIN_TICK) tickNext = _tickMath.TickMath.MIN_TICK;else if (tickNext > _tickMath.TickMath.MAX_TICK) tickNext = _tickMath.TickMath.MAX_TICK;
+        sqrtPriceNextX64 = _tickMath.TickMath.getSqrtRatioAtTick(tickNext);
+        const targetPrice = (zeroForOne ? sqrtPriceNextX64 < sqrtPriceLimit : sqrtPriceNextX64 > sqrtPriceLimit) ? sqrtPriceLimit : sqrtPriceNextX64;
+        [sqrtPriceX64, amountIn, amountOut, feeAmount] = _swapMath.SwapMath.computeSwapStep(sqrtPriceX64, targetPrice, liquidity, amountSpecifiedRemaining, this.fee);
         if (exactInput) {
-          state.amountSpecifiedRemaining = state.amountSpecifiedRemaining - (step.amountIn + step.feeAmount);
-          state.amountCalculated = state.amountCalculated - step.amountOut;
+          amountSpecifiedRemaining = amountSpecifiedRemaining - (amountIn + feeAmount);
+          amountCalculated = amountCalculated - amountOut;
         } else {
-          state.amountSpecifiedRemaining = state.amountSpecifiedRemaining + step.amountOut;
-          state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount);
+          amountSpecifiedRemaining = amountSpecifiedRemaining + amountOut;
+          amountCalculated = amountCalculated + (amountIn + feeAmount);
         }
-        if (state.sqrtPriceX64 === step.sqrtPriceNextX64) {
-          if (step.initialized) {
-            let liquidityNet = BigInt(this.tickDataProvider.getTick(step.tickNext).liquidityNet);
+        if (sqrtPriceX64 === sqrtPriceNextX64) {
+          if (initialized) {
+            let liquidityNet = this.tickDataProvider.getTick(tickNext).liquidityNet;
             if (zeroForOne) liquidityNet = liquidityNet * _internalConstants.NEGATIVE_ONE;
-            state.liquidity = _liquidityMath.LiquidityMath.addDelta(state.liquidity, liquidityNet);
+            liquidity = _liquidityMath.LiquidityMath.addDelta(liquidity, liquidityNet);
           }
-          state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-        } else if (state.sqrtPriceX64 !== step.sqrtPriceStartX64) {
-          state.tick = _tickMath.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
+          tick = zeroForOne ? tickNext - 1 : tickNext;
+        } else if (sqrtPriceX64 !== sqrtPriceStartX64) {
+          tick = _tickMath.TickMath.getTickAtSqrtRatio(sqrtPriceX64);
         }
       }
       return {
-        amountA: zeroForOne === exactInput ? amountSpecified - state.amountSpecifiedRemaining : state.amountCalculated,
-        amountB: zeroForOne === exactInput ? state.amountCalculated : amountSpecified - state.amountSpecifiedRemaining,
-        sqrtPriceX64: state.sqrtPriceX64,
-        liquidity: state.liquidity,
-        tickCurrent: state.tick
+        amountA: zeroForOne === exactInput ? amountSpecified - amountSpecifiedRemaining : amountCalculated,
+        amountB: zeroForOne === exactInput ? amountCalculated : amountSpecified - amountSpecifiedRemaining,
+        sqrtPriceX64,
+        liquidity,
+        tickCurrent: tick
       };
     }
   }, {

package/build/entities/tickListDataProvider.d.ts

@@ -5,9 +5,14 @@ import { TickDataProvider } from "./tickDataProvider";
  */
 export declare class TickListDataProvider implements TickDataProvider {
     ticks: readonly Tick[];
+    private _cursorIndex;
     constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number);
     getTick(tick: number): Tick;
+    /** Reset cursor for new swap */
+    resetCursor(): void;
     nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+    /** Optimized version with cursor - O(1) for sequential access */
+    nextInitializedTickWithinOneWordWithCursor(tick: number, lte: boolean, tickSpacing: number): [number, boolean];
     static toJSON(ticks: Tick[]): object;
     static fromJSON(ticksArray: any): TickListDataProvider;
 }

package/build/entities/tickListDataProvider.js

@@ -19,6 +19,7 @@ let TickListDataProvider = exports.TickListDataProvider = /*#__PURE__*/function
   function TickListDataProvider(ticks, tickSpacing) {
     _classCallCheck(this, TickListDataProvider);
     _defineProperty(this, "ticks", void 0);
+    _defineProperty(this, "_cursorIndex", -1);
     const ticksMapped = ticks.map(t => t instanceof _tick.Tick ? t : new _tick.Tick(t));
     _tickList.TickList.validateList(ticksMapped, tickSpacing);
     this.ticks = ticksMapped;
@@ -28,11 +29,27 @@ let TickListDataProvider = exports.TickListDataProvider = /*#__PURE__*/function
     value: function getTick(tick) {
       return _tickList.TickList.getTick(this.ticks, tick);
     }
+
+    /** Reset cursor for new swap */
+  }, {
+    key: "resetCursor",
+    value: function resetCursor() {
+      this._cursorIndex = -1;
+    }
   }, {
     key: "nextInitializedTickWithinOneWord",
     value: function nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
       return _tickList.TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
     }
+
+    /** Optimized version with cursor - O(1) for sequential access */
+  }, {
+    key: "nextInitializedTickWithinOneWordWithCursor",
+    value: function nextInitializedTickWithinOneWordWithCursor(tick, lte, tickSpacing) {
+      const [tickNext, initialized, newCursor] = _tickList.TickList.nextInitializedTickWithinOneWordWithCursor(this.ticks, tick, lte, tickSpacing, this._cursorIndex);
+      this._cursorIndex = newCursor;
+      return [tickNext, initialized];
+    }
   }], [{
     key: "toJSON",
     value: function toJSON(ticks) {

package/build/entities/trade.d.ts

@@ -2,6 +2,7 @@ import { Currency } from './currency';
 import { Percent, Price, CurrencyAmount } from './fractions';
 import { TradeType } from '../internalConstants';
 import { Route } from './route';
+import { Pool } from './pool';
 /**
  * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
  * @template TInput The input token, either Ether or an ERC-20
@@ -105,6 +106,14 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @returns The exact out trade
      */
     static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>;
+    /**
+     * WASM-accelerated version of fromRoute (for EXACT_INPUT only)
+     * @param route route to swap through
+     * @param amount the input amount
+     * @param pools All pools for calculation
+     * @returns Promise of the trade
+     */
+    static fromRouteWASM<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amount: CurrencyAmount<TInput>, pools: Pool[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>>;
     /**
      * Constructs a trade by simulating swaps through the given route
      * @template TInput The input token, either Ether or an ERC-20.
@@ -191,6 +200,20 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
     static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
     static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
+    /**
+     * WASM-accelerated version of bestTradeWithSplit
+     * @param _routes Routes to consider
+     * @param amount Amount to swap
+     * @param percents Percentages to split
+     * @param tradeType Type of trade
+     * @param pools All pools for trade calculation
+     * @param swapConfig Configuration for splits
+     * @returns Best trade or null
+     */
+    static bestTradeWithSplitWASM<TInput extends Currency, TOutput extends Currency>(_routes: Route<TInput, TOutput>[], amount: CurrencyAmount<Currency>, percents: number[], tradeType: TradeType, pools: Pool[], swapConfig?: {
+        minSplits: number;
+        maxSplits: number;
+    }): Promise<Trade<Currency, Currency, TradeType> | null>;
     static bestTradeWithSplit<TInput extends Currency, TOutput extends Currency>(_routes: Route<TInput, TOutput>[], amount: CurrencyAmount<Currency>, percents: number[], tradeType: TradeType, swapConfig?: {
         minSplits: number;
         maxSplits: number;

package/build/entities/trade.js

@@ -14,6 +14,8 @@ var _getBestSwapRoute = require("../utils/getBestSwapRoute");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
 function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
 function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
@@ -302,6 +304,22 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       return Trade.fromRoute(route, amountOut, _internalConstants.TradeType.EXACT_OUTPUT);
     }
 
+    /**
+     * WASM-accelerated version of fromRoute (for EXACT_INPUT only)
+     * @param route route to swap through
+     * @param amount the input amount
+     * @param pools All pools for calculation
+     * @returns Promise of the trade
+     */
+  }, {
+    key: "fromRouteWASM",
+    value: async function fromRouteWASM(route, amount, pools) {
+      const {
+        createTradeFromRouteWASM
+      } = await Promise.resolve().then(() => _interopRequireWildcard(require('../utils/tradeCalculatorWASM')));
+      return createTradeFromRouteWASM(route, amount, _internalConstants.TradeType.EXACT_INPUT, pools);
+    }
+
     /**
      * Constructs a trade by simulating swaps through the given route
      * @template TInput The input token, either Ether or an ERC-20.
@@ -442,8 +460,38 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
     value: function bestTradeExactIn(routes, currencyAmountIn) {
       let maxNumResults = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
       (0, _tinyInvariant.default)(routes.length > 0, 'ROUTES');
+
+      // Pre-filter: remove routes with zero-liquidity pools
+      const validRoutes = routes.filter(route => route.pools.every(pool => pool.active && pool.liquidity > _internalConstants.ZERO));
+
+      // Helper: compute min liquidity using JSBI (no overflow)
+      const getMinLiquidity = route => {
+        let min = route.pools[0].liquidity;
+        for (let i = 1; i < route.pools.length; i++) {
+          if (route.pools[i].liquidity < min) {
+            min = route.pools[i].liquidity;
+          }
+        }
+        return min;
+      };
+
+      // Precompute min liquidity for sorting
+      const routeMinLiq = new Map();
+      for (const route of validRoutes) {
+        routeMinLiq.set(route, getMinLiquidity(route));
+      }
+
+      // Sort routes: fewer hops first, then by min liquidity desc
+      validRoutes.sort((a, b) => {
+        if (a.pools.length !== b.pools.length) return a.pools.length - b.pools.length;
+        const minLiqA = routeMinLiq.get(a);
+        const minLiqB = routeMinLiq.get(b);
+        if (minLiqA > minLiqB) return -1;
+        if (minLiqA < minLiqB) return 1;
+        return 0;
+      });
       const bestTrades = [];
-      for (const route of routes) {
+      for (const route of validRoutes) {
         let trade;
         try {
           trade = Trade.fromRoute(route, currencyAmountIn, _internalConstants.TradeType.EXACT_INPUT);
@@ -455,8 +503,8 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
           throw error;
         }
 
-        // FIXME! Sorting bug multiple pools
-        if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue;
+        // Only check outputAmount > 0, skip expensive priceImpact calculation
+        if (!trade.outputAmount.greaterThan(0)) continue;
         (0, _utils.sortedInsert)(bestTrades, trade, maxNumResults, tradeComparator);
       }
       return bestTrades;
@@ -483,6 +531,29 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       }
       return bestTrades;
     }
+
+    /**
+     * WASM-accelerated version of bestTradeWithSplit
+     * @param _routes Routes to consider
+     * @param amount Amount to swap
+     * @param percents Percentages to split
+     * @param tradeType Type of trade
+     * @param pools All pools for trade calculation
+     * @param swapConfig Configuration for splits
+     * @returns Best trade or null
+     */
+  }, {
+    key: "bestTradeWithSplitWASM",
+    value: async function bestTradeWithSplitWASM(_routes, amount, percents, tradeType, pools) {
+      let swapConfig = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
+        minSplits: 1,
+        maxSplits: 10
+      };
+      const {
+        bestTradeWithSplitWASM
+      } = await Promise.resolve().then(() => _interopRequireWildcard(require('../utils/tradeCalculatorWASM')));
+      return bestTradeWithSplitWASM(_routes, amount, percents, tradeType, pools, swapConfig);
+    }
   }, {
     key: "bestTradeWithSplit",
     value: function bestTradeWithSplit(_routes, amount, percents, tradeType) {
@@ -493,6 +564,35 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       (0, _tinyInvariant.default)(_routes.length > 0, 'ROUTES');
       (0, _tinyInvariant.default)(percents.length > 0, 'PERCENTS');
 
+      // Pre-filter: remove routes with zero-liquidity or inactive pools
+      const validRoutes = _routes.filter(route => route.pools.every(pool => pool.active && pool.liquidity > _internalConstants.ZERO));
+
+      // Helper: compute min liquidity for a route using JSBI (no overflow)
+      const getMinLiquidity = route => {
+        let min = route.pools[0].liquidity;
+        for (let i = 1; i < route.pools.length; i++) {
+          if (route.pools[i].liquidity < min) {
+            min = route.pools[i].liquidity;
+          }
+        }
+        return min;
+      };
+
+      // Precompute min liquidity for sorting (avoid recalculating)
+      const routeMinLiq = new Map();
+      for (const route of validRoutes) {
+        routeMinLiq.set(route, getMinLiquidity(route));
+      }
+
+      // Sort routes by min liquidity (descending) - no hop preference
+      validRoutes.sort((a, b) => {
+        const minLiqA = routeMinLiq.get(a);
+        const minLiqB = routeMinLiq.get(b);
+        if (minLiqA > minLiqB) return -1;
+        if (minLiqA < minLiqB) return 1;
+        return 0;
+      });
+
       // Предварительно вычисляем splitAmount для всех процентов
       const percentToAmount = new Map();
       for (const percent of percents) {
@@ -506,13 +606,14 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       }
 
       // Оптимизируем внутренний цикл - группируем вычисления по маршрутам
-      for (const route of _routes) {
-        // Для каждого маршрута проходим по всем процентам
+      for (const route of validRoutes) {
         for (const percent of percents) {
           const splitAmount = percentToAmount.get(percent);
           try {
             const trade = Trade.fromRoute(route, splitAmount, tradeType, percent);
-            if (trade.inputAmount.greaterThan(0) && trade.priceImpact.greaterThan(0)) {
+
+            // Only check outputAmount > 0, skip expensive priceImpact calculation
+            if (trade.outputAmount.greaterThan(0)) {
               percentToTrades.get(percent).push(trade);
             }
           } catch (error) {

package/build/utils/fullMath.js

@@ -18,28 +18,18 @@ let FullMath = exports.FullMath = /*#__PURE__*/function () {
   return _createClass(FullMath, null, [{
     key: "mulDivRoundingUp",
     value: function mulDivRoundingUp(a, b, denominator) {
-      // Check for division by zero
-      if (denominator === ZERO) {
-        throw new Error("Division by zero");
-      }
-
-      // Early return for zero inputs
+      // Early return for zero inputs (most common fast path)
       if (a === ZERO || b === ZERO) {
         return ZERO;
       }
 
-      // Early return if denominator is one
-      if (denominator === ONE) {
-        return a * b;
-      }
-
-      // Calculate product, quotient, and remainder
+      // Calculate product and quotient (1 division instead of 2)
       const product = a * b;
       const quotient = product / denominator;
-      const remainder = product % denominator;
 
-      // Round up if there’s a non-zero remainder
-      if (remainder !== ZERO) {
+      // Round up if there's remainder: check if product !== quotient * denominator
+      // This avoids expensive % operation (which is another division internally)
+      if (product !== quotient * denominator) {
         return quotient + ONE;
       }
       return quotient;

package/build/utils/getBestSwapRoute.js

@@ -16,18 +16,18 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
   // Извлекаем уникальные пулы из всех маршрутов
   const allPools = [...new Set(Object.values(percentToQuotes).flatMap(routes => routes.flatMap(r => r.route.pools)))];
 
-  // Создаем битовую карту для пулов
+  // Создаем битовую карту для пулов (bigint для поддержки >31 пулов)
   const poolToBit = new Map();
-  let bitCounter = 0;
+  let bitCounter = BigInt(0);
   for (const pool of allPools) {
-    poolToBit.set(pool.id, 1 << bitCounter++);
+    poolToBit.set(pool.id, BigInt(1) << bitCounter++);
   }
 
   // Предвычисляем маски для всех маршрутов
   const routeToMask = new Map();
   for (const routes of Object.values(percentToQuotes)) {
     for (const route of routes) {
-      let mask = 0;
+      let mask = BigInt(0);
       for (const pool of route.route.pools) {
         mask |= poolToBit.get(pool.id);
       }
@@ -76,7 +76,7 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
     }
   }
 
-  // Очередь для обработки комбинаций маршрутов
+  // Очередь для обработки комбинаций маршрутов (с usedMask для быстрой проверки overlap)
   const queue = new _queue.default();
   if (percents.length === 0) return null;
 
@@ -90,6 +90,7 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
         curRoutes: [topRoutes[0]],
         percentIndex: i,
         remainingPercent: 100 - percent,
+        usedMask: routeToMask.get(topRoutes[0]),
         special: false
       });
     }
@@ -98,6 +99,7 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
         curRoutes: [topRoutes[1]],
         percentIndex: i,
         remainingPercent: 100 - percent,
+        usedMask: routeToMask.get(topRoutes[1]),
         special: true
       });
     }
@@ -121,6 +123,7 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
         remainingPercent,
         curRoutes,
         percentIndex,
+        usedMask,
         special
       } = queue.dequeue();
       for (let i = percentIndex; i >= 0; i--) {
@@ -128,11 +131,12 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
         if (percentA > remainingPercent) continue;
         if (!percentToSortedQuotes[percentA] || percentToSortedQuotes[percentA].length === 0) continue;
         const candidateRoutesA = percentToSortedQuotes[percentA];
-        const routeWithQuoteA = findFirstRouteNotUsingUsedPools(curRoutes, candidateRoutesA, routeToMask);
+        const routeWithQuoteA = findFirstRouteNotUsingUsedPools(usedMask, candidateRoutesA, routeToMask);
         if (!routeWithQuoteA) continue;
         const remainingPercentNew = remainingPercent - percentA;
         const curRoutesNew = curRoutes.slice();
         curRoutesNew.push(routeWithQuoteA);
+        const usedMaskNew = usedMask | routeToMask.get(routeWithQuoteA);
         if (remainingPercentNew === 0 && splits >= minSplits) {
           const quotesNew = curRoutesNew.map(r => r.outputAmount);
           const quoteNew = sumFn(quotesNew);
@@ -149,6 +153,7 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
             curRoutes: curRoutesNew,
             remainingPercent: remainingPercentNew,
             percentIndex: i,
+            usedMask: usedMaskNew,
             special
           });
         }
@@ -165,14 +170,10 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
 }
 
 // Вспомогательная функция для поиска маршрута без пересекающихся пулов
-const findFirstRouteNotUsingUsedPools = (usedRoutes, candidateRoutes, routeToMask) => {
-  let usedMask = 0;
-  for (const route of usedRoutes) {
-    usedMask |= routeToMask.get(route);
-  }
+const findFirstRouteNotUsingUsedPools = (usedMask, candidateRoutes, routeToMask) => {
   for (const candidate of candidateRoutes) {
     const candidateMask = routeToMask.get(candidate);
-    if ((candidateMask & usedMask) === 0) {
+    if ((candidateMask & usedMask) === BigInt(0)) {
       return candidate;
     }
   }

package/build/utils/swapMath.js

@@ -13,7 +13,26 @@ function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r),
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 const MAX_FEE = 10n ** 6n;
-const MAX_FEE_MINUS_FEE_PIPS = feePips => MAX_FEE - BigInt(feePips);
+
+// Cache for fee factors - feePips values are limited (100, 500, 3000, 10000)
+const feeFactorCache = new Map();
+const feePipsCache = new Map();
+function getFeeFactor(feePips) {
+  let cached = feeFactorCache.get(feePips);
+  if (cached === undefined) {
+    cached = MAX_FEE - getFeePipsBigInt(feePips);
+    feeFactorCache.set(feePips, cached);
+  }
+  return cached;
+}
+function getFeePipsBigInt(feePips) {
+  let cached = feePipsCache.get(feePips);
+  if (cached === undefined) {
+    cached = BigInt(feePips);
+    feePipsCache.set(feePips, cached);
+  }
+  return cached;
+}
 let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
   /**
    * Cannot be constructed.
@@ -31,7 +50,7 @@ let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
       let amountOut;
       let feeAmount;
       if (exactIn) {
-        const feeFactor = MAX_FEE_MINUS_FEE_PIPS(feePips);
+        const feeFactor = getFeeFactor(feePips);
         const amountRemainingLessFee = amountRemaining * feeFactor / MAX_FEE;
         const deltaIn = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, true) : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, true);
         if (amountRemainingLessFee >= deltaIn) {
@@ -42,7 +61,7 @@ let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
           amountIn = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, true) : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, sqrtRatioNextX64, liquidity, true);
         }
         amountOut = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, false) : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioNextX64, liquidity, false);
-        feeAmount = sqrtRatioNextX64 !== sqrtRatioTargetX64 ? amountRemaining - amountIn : _fullMath.FullMath.mulDivRoundingUp(amountIn, BigInt(feePips), feeFactor);
+        feeAmount = sqrtRatioNextX64 !== sqrtRatioTargetX64 ? amountRemaining - amountIn : _fullMath.FullMath.mulDivRoundingUp(amountIn, getFeePipsBigInt(feePips), feeFactor);
       } else {
         const deltaOut = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, false) : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, false);
         const amountRemainingNegative = amountRemaining * _internalConstants.NEGATIVE_ONE;
@@ -57,7 +76,7 @@ let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
         if (amountOut > amountRemainingNegative) {
           amountOut = amountRemainingNegative;
         }
-        feeAmount = _fullMath.FullMath.mulDivRoundingUp(amountIn, BigInt(feePips), MAX_FEE_MINUS_FEE_PIPS(feePips));
+        feeAmount = _fullMath.FullMath.mulDivRoundingUp(amountIn, getFeePipsBigInt(feePips), getFeeFactor(feePips));
       }
       return [sqrtRatioNextX64, amountIn, amountOut, feeAmount];
     }

package/build/utils/tickList.d.ts

@@ -20,4 +20,10 @@ export declare abstract class TickList {
     private static binarySearch;
     static nextInitializedTick(ticks: readonly Tick[], tick: number, lte: boolean): Tick;
     static nextInitializedTickWithinOneWord(ticks: readonly Tick[], tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+    /**
+     * Optimized version with cursor hint for sequential access (swap loops)
+     * @param cursorHint - last known index position, -1 if unknown
+     * @returns [tickId, initialized, newCursorIndex]
+     */
+    static nextInitializedTickWithinOneWordWithCursor(ticks: readonly Tick[], tick: number, lte: boolean, tickSpacing: number, cursorHint: number): [number, boolean, number];
 }

package/build/utils/tickList.js

@@ -144,5 +144,61 @@ let TickList = exports.TickList = /*#__PURE__*/function () {
         return [nextInitializedTick, nextInitializedTick === ticks[id + 1].id];
       }
     }
+
+    /**
+     * Optimized version with cursor hint for sequential access (swap loops)
+     * @param cursorHint - last known index position, -1 if unknown
+     * @returns [tickId, initialized, newCursorIndex]
+     */
+  }, {
+    key: "nextInitializedTickWithinOneWordWithCursor",
+    value: function nextInitializedTickWithinOneWordWithCursor(ticks, tick, lte, tickSpacing, cursorHint) {
+      const compressed = Math.floor(tick / tickSpacing);
+      const tickCount = ticks.length;
+      if (lte) {
+        const wordPos = compressed >> 7;
+        const minimum = (wordPos << 7) * tickSpacing;
+        if (tick < ticks[0].id) return [minimum, false, -1];
+        if (tick >= ticks[tickCount - 1].id) return [ticks[tickCount - 1].id, true, tickCount - 1];
+
+        // Use cursor hint for O(1) lookup if valid
+        let id;
+        if (cursorHint >= 0 && cursorHint < tickCount) {
+          // Linear scan from hint (swap moves monotonically)
+          if (ticks[cursorHint].id <= tick && (cursorHint === tickCount - 1 || ticks[cursorHint + 1].id > tick)) {
+            id = cursorHint;
+          } else if (cursorHint > 0 && ticks[cursorHint - 1].id <= tick && ticks[cursorHint].id > tick) {
+            id = cursorHint - 1;
+          } else {
+            id = this.binarySearch(ticks, tick);
+          }
+        } else {
+          id = this.binarySearch(ticks, tick);
+        }
+        const nextInitializedTick = Math.max(minimum, ticks[id].id);
+        return [nextInitializedTick, nextInitializedTick === ticks[id].id, id];
+      } else {
+        const wordPos = compressed + 1 >> 7;
+        const maximum = ((wordPos + 1 << 7) - 1) * tickSpacing;
+        if (tick >= ticks[tickCount - 1].id) return [maximum, false, tickCount - 1];
+        if (tick < ticks[0].id) return [ticks[0].id, true, 0];
+
+        // Use cursor hint for O(1) lookup if valid
+        let id;
+        if (cursorHint >= 0 && cursorHint < tickCount - 1) {
+          if (ticks[cursorHint].id <= tick && ticks[cursorHint + 1].id > tick) {
+            id = cursorHint;
+          } else if (cursorHint < tickCount - 2 && ticks[cursorHint + 1].id <= tick && ticks[cursorHint + 2].id > tick) {
+            id = cursorHint + 1;
+          } else {
+            id = this.binarySearch(ticks, tick);
+          }
+        } else {
+          id = this.binarySearch(ticks, tick);
+        }
+        const nextInitializedTick = Math.min(maximum, ticks[id + 1].id);
+        return [nextInitializedTick, nextInitializedTick === ticks[id + 1].id, id];
+      }
+    }
   }]);
 }();

package/build/utils/tickMath.d.ts

@@ -16,6 +16,10 @@ export declare abstract class TickMath {
      * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
      */
     static MAX_SQRT_RATIO: JSBI;
+    /**
+     * Clears all caches. Call this if memory usage is a concern.
+     */
+    static clearCache(): void;
     /**
      * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
      * @param tick the tick for which to compute the sqrt ratio

package/build/utils/tickMath.js

@@ -18,18 +18,37 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 function mulShift(val, mulBy) {
   return val * BigInt(mulBy) >> 128n;
 }
+
+// Memoization caches
+const sqrtRatioCache = new Map();
+const tickAtSqrtRatioCache = new Map();
 let TickMath = exports.TickMath = /*#__PURE__*/function () {
   function TickMath() {
     _classCallCheck(this, TickMath);
   }
   return _createClass(TickMath, null, [{
-    key: "getSqrtRatioAtTick",
+    key: "clearCache",
     value:
+    /**
+     * Clears all caches. Call this if memory usage is a concern.
+     */
+    function clearCache() {
+      sqrtRatioCache.clear();
+      tickAtSqrtRatioCache.clear();
+    }
+
     /**
      * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
      * @param tick the tick for which to compute the sqrt ratio
      */
-    function getSqrtRatioAtTick(tick) {
+  }, {
+    key: "getSqrtRatioAtTick",
+    value: function getSqrtRatioAtTick(tick) {
+      // Check cache first
+      const cached = sqrtRatioCache.get(tick);
+      if (cached !== undefined) {
+        return cached;
+      }
       (0, _tinyInvariant.default)(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
       const absTick = tick < 0 ? tick * -1 : tick;
       let ratio = (absTick & 0x1) != 0 ? BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : BigInt("0x100000000000000000000000000000000");
@@ -55,7 +74,11 @@ let TickMath = exports.TickMath = /*#__PURE__*/function () {
       if (tick > 0) ratio = _internalConstants.MaxUint256 / ratio;
 
       // back to Q64
-      return ratio % _internalConstants.Q64 > _internalConstants.ZERO ? ratio / _internalConstants.Q64 + _internalConstants.ONE : ratio / _internalConstants.Q64;
+      const result = ratio % _internalConstants.Q64 > _internalConstants.ZERO ? ratio / _internalConstants.Q64 + _internalConstants.ONE : ratio / _internalConstants.Q64;
+
+      // Store in cache
+      sqrtRatioCache.set(tick, result);
+      return result;
     }
 
     /**
@@ -66,6 +89,12 @@ let TickMath = exports.TickMath = /*#__PURE__*/function () {
   }, {
     key: "getTickAtSqrtRatio",
     value: function getTickAtSqrtRatio(sqrtRatioX64) {
+      // Check cache first
+      const cacheKey = sqrtRatioX64.toString();
+      const cached = tickAtSqrtRatioCache.get(cacheKey);
+      if (cached !== undefined) {
+        return cached;
+      }
       (0, _tinyInvariant.default)(sqrtRatioX64 >= TickMath.MIN_SQRT_RATIO && sqrtRatioX64 < TickMath.MAX_SQRT_RATIO, "SQRT_RATIO");
       const sqrtRatioX128 = sqrtRatioX64 << 64n;
       const msb = (0, _mostSignificantBit.mostSignificantBit)(sqrtRatioX128);
@@ -85,7 +114,11 @@ let TickMath = exports.TickMath = /*#__PURE__*/function () {
       const log_sqrt10001 = log_2 * 255738958999603826347141n;
       const tickLow = Number(log_sqrt10001 - 3402992956809132418596140100660247210n >> 128n);
       const tickHigh = Number(log_sqrt10001 + 291339464771989622907027621153398088495n >> 128n);
-      return tickLow === tickHigh ? tickLow : TickMath.getSqrtRatioAtTick(tickHigh) <= sqrtRatioX64 ? tickHigh : tickLow;
+      const result = tickLow === tickHigh ? tickLow : TickMath.getSqrtRatioAtTick(tickHigh) <= sqrtRatioX64 ? tickHigh : tickLow;
+
+      // Store in cache
+      tickAtSqrtRatioCache.set(cacheKey, result);
+      return result;
     }
   }]);
 }();

package/build/utils/tradeCalculatorWASM.d.ts

@@ -0,0 +1,45 @@
+import { Token, Pool, Route, Trade } from '../entities';
+import { CurrencyAmount } from '../entities/fractions';
+import { TradeType } from '../internalConstants';
+/**
+ * WASM-accelerated trade calculator
+ */
+export declare class WASMTradeCalculator {
+    private initialized;
+    private poolsMap;
+    /**
+     * Initialize with pools including full swap data
+     */
+    initializeWithPools(pools: Pool[]): Promise<void>;
+    /**
+     * Calculate trade output for a single route (WASM-accelerated)
+     */
+    calculateTradeOutput(route: Route<Token, Token>, amountIn: CurrencyAmount<Token>): {
+        amountOut: CurrencyAmount<Token>;
+        priceImpact: number;
+    };
+    /**
+     * Batch calculate trades for multiple routes and amounts
+     */
+    calculateTradesBatch(routes: Route<Token, Token>[], amounts: CurrencyAmount<Token>[]): Array<{
+        route: Route<Token, Token>;
+        amountIn: CurrencyAmount<Token>;
+        amountOut: CurrencyAmount<Token>;
+        priceImpact: number;
+    }>;
+    /**
+     * Clear all pools from memory
+     */
+    clear(): void;
+}
+/**
+ * Create a WASM-accelerated Trade from a route
+ */
+export declare function createTradeFromRouteWASM(route: Route<Token, Token>, amount: CurrencyAmount<Token>, tradeType: TradeType, pools: Pool[]): Promise<Trade<Token, Token, TradeType>>;
+/**
+ * Find best trade with split using WASM acceleration
+ */
+export declare function bestTradeWithSplitWASM(routes: Route<Token, Token>[], amount: CurrencyAmount<Token>, percents: number[], tradeType: TradeType, pools: Pool[], swapConfig?: {
+    minSplits: number;
+    maxSplits: number;
+}): Promise<Trade<Token, Token, TradeType> | null>;

package/build/utils/tradeCalculatorWASM.js

@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WASMTradeCalculator = void 0;
+exports.bestTradeWithSplitWASM = bestTradeWithSplitWASM;
+exports.createTradeFromRouteWASM = createTradeFromRouteWASM;
+var _entities = require("../entities");
+var _fractions = require("../entities/fractions");
+var _internalConstants = require("../internalConstants");
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// WASM module - lazy loaded
+let wasmModule = null;
+function loadWasmModule() {
+  if (!wasmModule) {
+    try {
+      wasmModule = require('./wasm_route_finder.js');
+    } catch (error) {
+      console.error('Failed to load WASM module:', error);
+      throw new Error('WASM module not available');
+    }
+  }
+  return wasmModule;
+}
+
+/**
+ * WASM-accelerated trade calculator
+ */
+let WASMTradeCalculator = exports.WASMTradeCalculator = /*#__PURE__*/function () {
+  function WASMTradeCalculator() {
+    _classCallCheck(this, WASMTradeCalculator);
+    _defineProperty(this, "initialized", false);
+    _defineProperty(this, "poolsMap", new Map());
+  }
+  return _createClass(WASMTradeCalculator, [{
+    key: "initializeWithPools",
+    value:
+    /**
+     * Initialize with pools including full swap data
+     */
+    async function initializeWithPools(pools) {
+      loadWasmModule();
+
+      // Build pool map for fast lookup
+      this.poolsMap.clear();
+      for (const pool of pools) {
+        this.poolsMap.set(pool.id, pool);
+      }
+
+      // Convert pools to format needed by WASM (including swap data)
+      const wasmPools = pools.map(pool => {
+        // Extract ticks from tickDataProvider if available
+        let ticks = [];
+        const tickProvider = pool.tickDataProvider;
+        if (tickProvider && tickProvider.ticks) {
+          ticks = tickProvider.ticks.map(tick => ({
+            id: tick.id || tick.index,
+            index: tick.id || tick.index,
+            liquidityNet: (tick.liquidityNet || '0').toString(),
+            liquidityGross: (tick.liquidityGross || '0').toString()
+          }));
+        }
+        return {
+          id: String(pool.id),
+          token_a: {
+            id: pool.tokenA.id
+          },
+          token_b: {
+            id: pool.tokenB.id
+          },
+          fee: pool.fee,
+          sqrtPriceX64: pool.sqrtPriceX64.toString(),
+          liquidity: pool.liquidity.toString(),
+          tickCurrent: pool.tickCurrent,
+          ticks
+        };
+      });
+
+      // Initialize pools with full data in WASM
+      wasmModule.init_pools_with_data(wasmPools);
+      this.initialized = true;
+    }
+
+    /**
+     * Calculate trade output for a single route (WASM-accelerated)
+     */
+  }, {
+    key: "calculateTradeOutput",
+    value: function calculateTradeOutput(route, amountIn) {
+      if (!this.initialized) {
+        throw new Error('WASMTradeCalculator not initialized');
+      }
+      const poolIds = new Uint32Array(route.pools.map(p => p.id));
+      const result = wasmModule.calculate_trade_output(poolIds, amountIn.quotient.toString(), route.input.id);
+
+      // Check if result is valid
+      // The result might be a Map or an object depending on wasm-bindgen
+      let amountOutValue;
+      let priceImpactValue = 0;
+      if (result instanceof Map) {
+        amountOutValue = result.get('amountOut');
+        priceImpactValue = result.get('priceImpact') || 0;
+      } else if (result && typeof result === 'object') {
+        amountOutValue = result.amountOut;
+        priceImpactValue = result.priceImpact || 0;
+      }
+      if (!amountOutValue) {
+        console.error('WASM returned invalid result:', result);
+        throw new Error('WASM trade calculation failed - no amountOut');
+      }
+      const amountOut = _fractions.CurrencyAmount.fromRawAmount(route.output, BigInt(amountOutValue));
+      return {
+        amountOut,
+        priceImpact: priceImpactValue
+      };
+    }
+
+    /**
+     * Batch calculate trades for multiple routes and amounts
+     */
+  }, {
+    key: "calculateTradesBatch",
+    value: function calculateTradesBatch(routes, amounts) {
+      var _routes$;
+      if (!this.initialized) {
+        throw new Error('WASMTradeCalculator not initialized');
+      }
+
+      // Convert routes to pool ID arrays
+      const routePoolIds = routes.map(route => route.pools.map(p => p.id));
+
+      // Convert amounts to strings
+      const amountStrings = amounts.map(a => a.quotient.toString());
+
+      // Assume all routes have same input token
+      const tokenInId = ((_routes$ = routes[0]) === null || _routes$ === void 0 ? void 0 : _routes$.input.id) || '';
+      const results = wasmModule.calculate_trades_for_routes(routePoolIds, amountStrings, tokenInId);
+      const trades = [];
+      let resultIdx = 0;
+      for (const route of routes) {
+        for (const amount of amounts) {
+          const result = results[resultIdx++];
+          if (result.success) {
+            trades.push({
+              route,
+              amountIn: amount,
+              amountOut: _fractions.CurrencyAmount.fromRawAmount(route.output, BigInt(result.amountOut)),
+              priceImpact: result.priceImpact
+            });
+          }
+        }
+      }
+      return trades;
+    }
+
+    /**
+     * Clear all pools from memory
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      if (this.initialized) {
+        wasmModule.clear_pools();
+        this.poolsMap.clear();
+        this.initialized = false;
+      }
+    }
+  }]);
+}();
+/**
+ * Create a WASM-accelerated Trade from a route
+ */
+async function createTradeFromRouteWASM(route, amount, tradeType, pools) {
+  const calculator = new WASMTradeCalculator();
+  await calculator.initializeWithPools(pools);
+  try {
+    if (tradeType === _internalConstants.TradeType.EXACT_INPUT) {
+      const {
+        amountOut
+      } = calculator.calculateTradeOutput(route, amount);
+      return _entities.Trade.createUncheckedTrade({
+        route,
+        inputAmount: amount,
+        outputAmount: amountOut,
+        tradeType: _internalConstants.TradeType.EXACT_INPUT,
+        percent: 100
+      });
+    } else {
+      // For EXACT_OUTPUT, we'd need to implement reverse calculation
+      // For now, fall back to JS implementation
+      return _entities.Trade.fromRoute(route, amount, tradeType);
+    }
+  } finally {
+    calculator.clear();
+  }
+}
+
+/**
+ * Find best trade with split using WASM acceleration
+ */
+async function bestTradeWithSplitWASM(routes, amount, percents, tradeType, pools) {
+  let swapConfig = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
+    minSplits: 1,
+    maxSplits: 10
+  };
+  const calculator = new WASMTradeCalculator();
+  await calculator.initializeWithPools(pools);
+  try {
+    // Calculate all split amounts
+    const splitAmounts = percents.map(percent => _fractions.CurrencyAmount.fromRawAmount(amount.currency, amount.quotient * BigInt(percent) / 100n));
+
+    // Batch calculate all trades
+    const allTrades = calculator.calculateTradesBatch(routes, splitAmounts);
+
+    // Group trades by percent
+    const tradesByPercent = {};
+    let tradeIdx = 0;
+    for (let i = 0; i < percents.length; i++) {
+      const percent = percents[i];
+      tradesByPercent[percent] = [];
+      for (const route of routes) {
+        const tradeDat = allTrades[tradeIdx++];
+        if (tradeDat) {
+          const trade = _entities.Trade.createUncheckedTrade({
+            route: tradeDat.route,
+            inputAmount: tradeDat.amountIn,
+            outputAmount: tradeDat.amountOut,
+            tradeType,
+            percent
+          });
+          tradesByPercent[percent].push(trade);
+        }
+      }
+    }
+
+    // Use existing getBestSwapRoute logic
+    const {
+      getBestSwapRoute
+    } = require('./getBestSwapRoute');
+    const bestTrades = getBestSwapRoute(tradeType, tradesByPercent, percents, swapConfig);
+    if (!bestTrades) return null;
+    const routeData = bestTrades.map(trade => ({
+      inputAmount: trade.inputAmount,
+      outputAmount: trade.outputAmount,
+      route: trade.route,
+      percent: trade.swaps[0].percent
+    }));
+    return _entities.Trade.createUncheckedTradeWithMultipleRoutes({
+      routes: routeData,
+      tradeType
+    });
+  } finally {
+    calculator.clear();
+  }
+}

package/build/utils/wasm_route_finder.js

@@ -226,6 +226,67 @@ module.exports.get_pool_count = function() {
     return ret >>> 0;
 };
 
+/**
+ * @param {any} pools_js
+ */
+module.exports.init_pools_with_data = function(pools_js) {
+    const ret = wasm.init_pools_with_data(pools_js);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+};
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * @param {Uint32Array} route_pool_ids
+ * @param {string} amount_in
+ * @param {string} token_in_id
+ * @returns {any}
+ */
+module.exports.calculate_trade_output = function(route_pool_ids, amount_in, token_in_id) {
+    const ptr0 = passArray32ToWasm0(route_pool_ids, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(amount_in, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(token_in_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.calculate_trade_output(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @param {any} routes_js
+ * @param {any} amounts_js
+ * @param {string} token_in_id
+ * @returns {any}
+ */
+module.exports.calculate_trades_for_routes = function(routes_js, amounts_js, token_in_id) {
+    const ptr0 = passStringToWasm0(token_in_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.calculate_trades_for_routes(routes_js, amounts_js, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
 module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
     const ret = arg0.buffer;
     return ret;
@@ -314,6 +375,20 @@ module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_log_c222819a41e063d3 = function(arg0) {
+    console.log(arg0);
+};
+
+module.exports.__wbg_new_405e22f390576ce2 = function() {
+    const ret = new Object();
+    return ret;
+};
+
+module.exports.__wbg_new_5e0be73521bc8c17 = function() {
+    const ret = new Map();
+    return ret;
+};
+
 module.exports.__wbg_new_78feb108b6472713 = function() {
     const ret = new Array();
     return ret;
@@ -338,15 +413,29 @@ module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
     arg0[arg1 >>> 0] = arg2;
 };
 
+module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+};
+
 module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
     arg0.set(arg1, arg2 >>> 0);
 };
 
+module.exports.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+};
+
 module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
     const ret = arg0.value;
     return ret;
 };
 
+module.exports.__wbindgen_as_number = function(arg0) {
+    const ret = +arg0;
+    return ret;
+};
+
 module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
     const ret = arg0;
     return ret;
@@ -415,6 +504,11 @@ module.exports.__wbindgen_is_object = function(arg0) {
     return ret;
 };
 
+module.exports.__wbindgen_is_string = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
 module.exports.__wbindgen_jsval_eq = function(arg0, arg1) {
     const ret = arg0 === arg1;
     return ret;
@@ -437,6 +531,11 @@ module.exports.__wbindgen_number_get = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 };
 
+module.exports.__wbindgen_number_new = function(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
 module.exports.__wbindgen_string_get = function(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.402",
+  "version": "1.0.403",
   "description": "",
   "main": "build/index.js",
   "files": [