@alcorexchange/alcor-swap-sdk 1.1.2 → 1.1.4

package/build/entities/pool.js

@@ -170,10 +170,7 @@ let Pool = exports.Pool = /*#__PURE__*/function () {
       const outputToken = zeroForOne ? this.tokenB : this.tokenA;
       const outputAmount = zeroForOne ? amountB : amountA;
       const amountIn = zeroForOne ? amountA : amountB;
-
-      //console.log((amountIn === inputAmount.quotient))
-      if (!(inputAmount.quotient >= amountIn)) {
-        //if (!(amountIn === inputAmount.quotient)) {
+      if (!(amountIn === inputAmount.quotient)) {
         throw new _errors.InsufficientInputAmountError();
       }
       return _fractions.CurrencyAmount.fromRawAmount(outputToken, outputAmount * _internalConstants.NEGATIVE_ONE);

package/build/entities/trade.d.ts

@@ -217,5 +217,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     static bestTradeWithSplit<TInput extends Currency, TOutput extends Currency>(_routes: Route<TInput, TOutput>[], amount: CurrencyAmount<Currency>, percents: number[], tradeType: TradeType, swapConfig?: {
         minSplits: number;
         maxSplits: number;
+        branchFactor?: number;
+        candidateLimit?: number;
     }): Trade<Currency, Currency, TradeType> | null;
 }

package/build/entities/trade.js

@@ -604,23 +604,46 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       for (const percent of percents) {
         percentToAmount.set(percent, amount.multiply(percent).divide(100));
       }
-
-      // Используем Map вместо объекта для лучшей производительности
-      const percentToTrades = new Map();
+      const quoteRoute = (route, splitAmount, percent) => {
+        const amounts = new Array(route.tokenPath.length);
+        let inputAmount;
+        let outputAmount;
+        if (tradeType === _internalConstants.TradeType.EXACT_INPUT) {
+          amounts[0] = splitAmount;
+          for (let i = 0; i < route.tokenPath.length - 1; i++) {
+            amounts[i + 1] = route.pools[i].getOutputAmount(amounts[i]);
+          }
+          inputAmount = splitAmount;
+          outputAmount = amounts[amounts.length - 1];
+        } else {
+          amounts[amounts.length - 1] = splitAmount;
+          for (let i = route.tokenPath.length - 1; i > 0; i--) {
+            amounts[i - 1] = route.pools[i - 1].getInputAmount(amounts[i]);
+          }
+          inputAmount = amounts[0];
+          outputAmount = splitAmount;
+        }
+        if (!outputAmount.greaterThan(0)) {
+          return null;
+        }
+        return {
+          percent,
+          route: route,
+          inputAmount,
+          outputAmount
+        };
+      };
+      const percentToQuotes = {};
       for (const percent of percents) {
-        percentToTrades.set(percent, []);
+        percentToQuotes[percent] = [];
       }
-
-      // Оптимизируем внутренний цикл - группируем вычисления по маршрутам
       for (const route of validRoutes) {
         for (const percent of percents) {
           const splitAmount = percentToAmount.get(percent);
           try {
-            const trade = Trade.fromRoute(route, splitAmount, tradeType, percent);
-
-            // Only check outputAmount > 0, skip expensive priceImpact calculation
-            if (trade.outputAmount.greaterThan(0)) {
-              percentToTrades.get(percent).push(trade);
+            const quote = quoteRoute(route, splitAmount, percent);
+            if (quote) {
+              percentToQuotes[percent].push(quote);
             }
           } catch (error) {
             if (error.isInsufficientReservesError || error.isInsufficientInputAmountError) {
@@ -630,25 +653,19 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
           }
         }
       }
-
-      // Преобразуем Map обратно в объект для совместимости с getBestSwapRoute
-      const percentToTradesObj = {};
-      percentToTrades.forEach((trades, percent) => {
-        percentToTradesObj[percent] = trades;
-      });
-      const bestTrades = (0, _getBestSwapRoute.getBestSwapRoute)(tradeType, percentToTradesObj, percents, swapConfig);
-      if (!bestTrades) return null;
-      const routes = bestTrades.map(({
+      const bestQuotes = (0, _getBestSwapRoute.getBestSwapRoute)(tradeType, percentToQuotes, percents, swapConfig);
+      if (!bestQuotes) return null;
+      const routes = bestQuotes.map(({
         inputAmount,
         outputAmount,
         route,
-        swaps
+        percent
       }) => {
         return {
           inputAmount,
           outputAmount,
           route,
-          percent: swaps[0].percent
+          percent
         };
       });
 

package/build/esm/entities/pool.js

@@ -164,10 +164,7 @@ export let Pool = /*#__PURE__*/function () {
       const outputToken = zeroForOne ? this.tokenB : this.tokenA;
       const outputAmount = zeroForOne ? amountB : amountA;
       const amountIn = zeroForOne ? amountA : amountB;
-
-      //console.log((amountIn === inputAmount.quotient))
-      if (!(inputAmount.quotient >= amountIn)) {
-        //if (!(amountIn === inputAmount.quotient)) {
+      if (!(amountIn === inputAmount.quotient)) {
         throw new InsufficientInputAmountError();
       }
       return CurrencyAmount.fromRawAmount(outputToken, outputAmount * NEGATIVE_ONE);

package/build/esm/entities/trade.js

@@ -595,23 +595,46 @@ export let Trade = /*#__PURE__*/function () {
       for (const percent of percents) {
         percentToAmount.set(percent, amount.multiply(percent).divide(100));
       }
-
-      // Используем Map вместо объекта для лучшей производительности
-      const percentToTrades = new Map();
+      const quoteRoute = (route, splitAmount, percent) => {
+        const amounts = new Array(route.tokenPath.length);
+        let inputAmount;
+        let outputAmount;
+        if (tradeType === TradeType.EXACT_INPUT) {
+          amounts[0] = splitAmount;
+          for (let i = 0; i < route.tokenPath.length - 1; i++) {
+            amounts[i + 1] = route.pools[i].getOutputAmount(amounts[i]);
+          }
+          inputAmount = splitAmount;
+          outputAmount = amounts[amounts.length - 1];
+        } else {
+          amounts[amounts.length - 1] = splitAmount;
+          for (let i = route.tokenPath.length - 1; i > 0; i--) {
+            amounts[i - 1] = route.pools[i - 1].getInputAmount(amounts[i]);
+          }
+          inputAmount = amounts[0];
+          outputAmount = splitAmount;
+        }
+        if (!outputAmount.greaterThan(0)) {
+          return null;
+        }
+        return {
+          percent,
+          route: route,
+          inputAmount,
+          outputAmount
+        };
+      };
+      const percentToQuotes = {};
       for (const percent of percents) {
-        percentToTrades.set(percent, []);
+        percentToQuotes[percent] = [];
       }
-
-      // Оптимизируем внутренний цикл - группируем вычисления по маршрутам
       for (const route of validRoutes) {
         for (const percent of percents) {
           const splitAmount = percentToAmount.get(percent);
           try {
-            const trade = Trade.fromRoute(route, splitAmount, tradeType, percent);
-
-            // Only check outputAmount > 0, skip expensive priceImpact calculation
-            if (trade.outputAmount.greaterThan(0)) {
-              percentToTrades.get(percent).push(trade);
+            const quote = quoteRoute(route, splitAmount, percent);
+            if (quote) {
+              percentToQuotes[percent].push(quote);
             }
           } catch (error) {
             if (error.isInsufficientReservesError || error.isInsufficientInputAmountError) {
@@ -621,25 +644,19 @@ export let Trade = /*#__PURE__*/function () {
           }
         }
       }
-
-      // Преобразуем Map обратно в объект для совместимости с getBestSwapRoute
-      const percentToTradesObj = {};
-      percentToTrades.forEach((trades, percent) => {
-        percentToTradesObj[percent] = trades;
-      });
-      const bestTrades = getBestSwapRoute(tradeType, percentToTradesObj, percents, swapConfig);
-      if (!bestTrades) return null;
-      const routes = bestTrades.map(({
+      const bestQuotes = getBestSwapRoute(tradeType, percentToQuotes, percents, swapConfig);
+      if (!bestQuotes) return null;
+      const routes = bestQuotes.map(({
         inputAmount,
         outputAmount,
         route,
-        swaps
+        percent
       }) => {
         return {
           inputAmount,
           outputAmount,
           route,
-          percent: swaps[0].percent
+          percent
         };
       });
 

package/build/esm/utils/getBestSwapRoute.js

@@ -1,106 +1,78 @@
 import Queue from 'mnemonist/queue';
-import FixedReverseHeap from 'mnemonist/fixed-reverse-heap';
 import { TradeType } from '../internalConstants';
 export function getBestSwapRoute(routeType, percentToQuotes, percents, swapRouteConfig = {
   minSplits: 1,
   maxSplits: 8
 }) {
-  // Извлекаем уникальные пулы из всех маршрутов
-  const allPools = [...new Set(Object.values(percentToQuotes).flatMap(routes => routes.flatMap(r => r.route.pools)))];
+  const {
+    minSplits,
+    maxSplits,
+    branchFactor = 1,
+    candidateLimit = 0
+  } = swapRouteConfig;
+  const branchWidth = Math.max(1, branchFactor);
+  const quoteCompFn = routeType === TradeType.EXACT_INPUT ? (a, b) => a.greaterThan(b) : (a, b) => a.lessThan(b);
+  const quoteOf = routeType === TradeType.EXACT_INPUT ? q => q.outputAmount : q => q.inputAmount;
 
-  // Создаем битовую карту для пулов (bigint для поддержки >31 пулов)
+  // Build pool bit ids without intermediate arrays.
   const poolToBit = new Map();
   let bitCounter = BigInt(0);
-  for (const pool of allPools) {
-    poolToBit.set(pool.id, BigInt(1) << bitCounter++);
+  for (const quotes of Object.values(percentToQuotes)) {
+    for (const quote of quotes) {
+      for (const pool of quote.route.pools) {
+        if (!poolToBit.has(pool.id)) {
+          poolToBit.set(pool.id, BigInt(1) << bitCounter);
+          bitCounter += BigInt(1);
+        }
+      }
+    }
   }
-
-  // Предвычисляем маски для всех маршрутов
   const routeToMask = new Map();
-  for (const routes of Object.values(percentToQuotes)) {
-    for (const route of routes) {
+  for (const quotes of Object.values(percentToQuotes)) {
+    for (const quote of quotes) {
       let mask = BigInt(0);
-      for (const pool of route.route.pools) {
+      for (const pool of quote.route.pools) {
         mask |= poolToBit.get(pool.id);
       }
-      routeToMask.set(route, mask);
+      routeToMask.set(quote, mask);
     }
   }
-
-  // Сортируем маршруты для каждого процента
   const percentToSortedQuotes = {};
   for (const percent in percentToQuotes) {
-    percentToSortedQuotes[percent] = percentToQuotes[percent].sort((a, b) => routeType === TradeType.EXACT_INPUT ? a.outputAmount.greaterThan(b.outputAmount) ? -1 : 1 : a.inputAmount.lessThan(b.inputAmount) ? -1 : 1);
+    const sorted = percentToQuotes[percent].sort((a, b) => {
+      const qa = quoteOf(a);
+      const qb = quoteOf(b);
+      return quoteCompFn(qa, qb) ? -1 : 1;
+    });
+    percentToSortedQuotes[percent] = candidateLimit > 0 && sorted.length > candidateLimit ? sorted.slice(0, candidateLimit) : sorted;
   }
-
-  // Функция сравнения для типа торговли
-  const quoteCompFn = routeType === TradeType.EXACT_INPUT ? (a, b) => a.greaterThan(b) : (a, b) => a.lessThan(b);
-
-  // Функция суммирования CurrencyAmount
-  const sumFn = currencyAmounts => {
-    let sum = currencyAmounts[0];
-    for (let i = 1; i < currencyAmounts.length; i++) {
-      sum = sum.add(currencyAmounts[i]);
-    }
-    return sum;
-  };
   let bestQuote;
   let bestSwap;
-
-  // Храним лучшие маршруты для каждого уровня разбиения (максимум 3)
-  const bestSwapsPerSplit = new FixedReverseHeap(Array, (a, b) => quoteCompFn(a.quote, b.quote) ? -1 : 1, 3);
-  const {
-    minSplits,
-    maxSplits
-  } = swapRouteConfig;
-
-  // Проверяем наличие маршрута для 100% и инициализируем начальные данные
-  if (!percentToSortedQuotes[100] || percentToSortedQuotes[100].length === 0 || minSplits > 1) {
+  if ((!percentToSortedQuotes[100] || percentToSortedQuotes[100].length === 0) && minSplits <= 1) {
     console.log('Did not find a valid route without any splits. Continuing search anyway.');
-  } else {
-    bestQuote = percentToSortedQuotes[100][0].outputAmount;
+  } else if (minSplits <= 1 && percentToSortedQuotes[100] && percentToSortedQuotes[100][0]) {
     bestSwap = [percentToSortedQuotes[100][0]];
-    for (const routeWithQuote of percentToSortedQuotes[100].slice(0, 5)) {
-      bestSwapsPerSplit.push({
-        quote: routeWithQuote.outputAmount,
-        routes: [routeWithQuote]
-      });
-    }
+    bestQuote = quoteOf(percentToSortedQuotes[100][0]);
   }
-
-  // Очередь для обработки комбинаций маршрутов (с usedMask для быстрой проверки overlap)
   const queue = new Queue();
   if (percents.length === 0) return null;
-
-  // Инициализируем очередь с топ-2 маршрутами для каждого процента
   for (let i = percents.length - 1; i >= 0; i--) {
     const percent = percents[i];
-    if (!percentToSortedQuotes[percent] || percentToSortedQuotes[percent].length === 0) continue;
-    const topRoutes = percentToSortedQuotes[percent].slice(0, 2);
-    if (topRoutes[0]) {
+    const candidates = percentToSortedQuotes[percent];
+    if (!candidates || candidates.length === 0) continue;
+    const seeds = candidates.slice(0, branchWidth);
+    for (const seed of seeds) {
       queue.enqueue({
-        curRoutes: [topRoutes[0]],
+        curRoutes: [seed],
         percentIndex: i,
         remainingPercent: 100 - percent,
-        usedMask: routeToMask.get(topRoutes[0]),
-        special: false
-      });
-    }
-    if (topRoutes[1]) {
-      queue.enqueue({
-        curRoutes: [topRoutes[1]],
-        percentIndex: i,
-        remainingPercent: 100 - percent,
-        usedMask: routeToMask.get(topRoutes[1]),
-        special: true
+        usedMask: routeToMask.get(seed),
+        quoteSoFar: quoteOf(seed)
       });
     }
   }
   let splits = 1;
-
-  // Основной цикл поиска лучших маршрутов
   while (queue.size > 0) {
-    bestSwapsPerSplit.clear();
     let layer = queue.size;
     splits++;
     if (splits >= 3 && bestSwap && bestSwap.length < splits - 1) {
@@ -116,38 +88,37 @@ export function getBestSwapRoute(routeType, percentToQuotes, percents, swapRoute
         curRoutes,
         percentIndex,
         usedMask,
-        special
+        quoteSoFar
       } = queue.dequeue();
       for (let i = percentIndex; i >= 0; i--) {
-        const percentA = percents[i];
-        if (percentA > remainingPercent) continue;
-        if (!percentToSortedQuotes[percentA] || percentToSortedQuotes[percentA].length === 0) continue;
-        const candidateRoutesA = percentToSortedQuotes[percentA];
-        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);
-          bestSwapsPerSplit.push({
-            quote: quoteNew,
-            routes: curRoutesNew
-          });
-          if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
-            bestQuote = quoteNew;
-            bestSwap = curRoutesNew;
+        const percent = percents[i];
+        if (percent > remainingPercent) continue;
+        const candidates = percentToSortedQuotes[percent];
+        if (!candidates || candidates.length === 0) continue;
+        const routeCandidates = findRoutesNotUsingUsedPools(usedMask, candidates, routeToMask, branchWidth);
+        if (routeCandidates.length === 0) continue;
+        for (const candidate of routeCandidates) {
+          const remainingPercentNew = remainingPercent - percent;
+          const usedMaskNew = usedMask | routeToMask.get(candidate);
+          const quoteNew = quoteSoFar.add(quoteOf(candidate));
+          if (remainingPercentNew === 0 && splits >= minSplits) {
+            const curRoutesNew = curRoutes.slice();
+            curRoutesNew.push(candidate);
+            if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
+              bestQuote = quoteNew;
+              bestSwap = curRoutesNew;
+            }
+          } else {
+            const curRoutesNew = curRoutes.slice();
+            curRoutesNew.push(candidate);
+            queue.enqueue({
+              curRoutes: curRoutesNew,
+              remainingPercent: remainingPercentNew,
+              percentIndex: i,
+              usedMask: usedMaskNew,
+              quoteSoFar: quoteNew
+            });
           }
-        } else {
-          queue.enqueue({
-            curRoutes: curRoutesNew,
-            remainingPercent: remainingPercentNew,
-            percentIndex: i,
-            usedMask: usedMaskNew,
-            special
-          });
         }
       }
     }
@@ -156,18 +127,16 @@ export function getBestSwapRoute(routeType, percentToQuotes, percents, swapRoute
     console.log('Could not find a valid swap');
     return null;
   }
-  const quote = sumFn(bestSwap.map(routeWithValidQuote => routeWithValidQuote.outputAmount));
-  const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) => routeAmountB.outputAmount.greaterThan(routeAmountA.outputAmount) ? 1 : -1);
-  return routeWithQuotes;
+  return bestSwap;
 }
-
-// Вспомогательная функция для поиска маршрута без пересекающихся пулов
-const findFirstRouteNotUsingUsedPools = (usedMask, candidateRoutes, routeToMask) => {
+const findRoutesNotUsingUsedPools = (usedMask, candidateRoutes, routeToMask, limit) => {
+  const result = [];
   for (const candidate of candidateRoutes) {
     const candidateMask = routeToMask.get(candidate);
     if ((candidateMask & usedMask) === BigInt(0)) {
-      return candidate;
+      result.push(candidate);
+      if (result.length >= limit) return result;
     }
   }
-  return null;
+  return result;
 };

package/build/esm/utils/tradeCalculatorWASM.js

@@ -7,6 +7,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 import { Trade } from '../entities';
 import { CurrencyAmount } from '../entities/fractions';
 import { TradeType } from '../internalConstants';
+import { getBestSwapRoute } from './getBestSwapRoute';
 
 // WASM module - lazy loaded
 let wasmModule = null;
@@ -146,6 +147,8 @@ export let WASMTradeCalculator = /*#__PURE__*/function () {
               amountOut: CurrencyAmount.fromRawAmount(route.output, BigInt(result.amountOut)),
               priceImpact: result.priceImpact
             });
+          } else {
+            trades.push(null);
           }
         }
       }
@@ -212,37 +215,34 @@ export async function bestTradeWithSplitWASM(routes, amount, percents, tradeType
     const allTrades = calculator.calculateTradesBatch(routes, splitAmounts);
 
     // Group trades by percent
-    const tradesByPercent = {};
-    let tradeIdx = 0;
+    const quotesByPercent = {};
     for (let i = 0; i < percents.length; i++) {
       const percent = percents[i];
-      tradesByPercent[percent] = [];
-      for (const route of routes) {
-        const tradeDat = allTrades[tradeIdx++];
+      quotesByPercent[percent] = [];
+    }
+    const amountsPerRoute = splitAmounts.length;
+    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
+      for (let percentIndex = 0; percentIndex < percents.length; percentIndex++) {
+        const flatIndex = routeIndex * amountsPerRoute + percentIndex;
+        const tradeDat = allTrades[flatIndex];
         if (tradeDat) {
-          const trade = Trade.createUncheckedTrade({
+          const percent = percents[percentIndex];
+          quotesByPercent[percent].push({
             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);
+    const bestTrades = getBestSwapRoute(tradeType, quotesByPercent, 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
+      percent: trade.percent
     }));
     return Trade.createUncheckedTradeWithMultipleRoutes({
       routes: routeData,

package/build/utils/getBestSwapRoute.d.ts

@@ -1,9 +1,20 @@
 import { Currency } from '../entities/currency';
-import { Trade } from '../entities/trade';
+import { Route } from '../entities/route';
+import { CurrencyAmount } from '../entities/fractions';
 import { TradeType } from '../internalConstants';
-export declare function getBestSwapRoute(routeType: TradeType, percentToQuotes: {
-    [percent: number]: Trade<Currency, Currency, TradeType>[];
-}, percents: number[], swapRouteConfig?: {
+export interface SplitRouteQuote {
+    percent: number;
+    route: Route<Currency, Currency>;
+    inputAmount: CurrencyAmount<Currency>;
+    outputAmount: CurrencyAmount<Currency>;
+}
+interface SwapRouteConfig {
     minSplits: number;
     maxSplits: number;
-}): Trade<Currency, Currency, TradeType>[] | null;
+    branchFactor?: number;
+    candidateLimit?: number;
+}
+export declare function getBestSwapRoute(routeType: TradeType, percentToQuotes: {
+    [percent: number]: SplitRouteQuote[];
+}, percents: number[], swapRouteConfig?: SwapRouteConfig): SplitRouteQuote[] | null;
+export {};

package/build/utils/getBestSwapRoute.js

@@ -5,109 +5,81 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getBestSwapRoute = getBestSwapRoute;
 var _queue = _interopRequireDefault(require("mnemonist/queue"));
-var _fixedReverseHeap = _interopRequireDefault(require("mnemonist/fixed-reverse-heap"));
 var _internalConstants = require("../internalConstants");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function getBestSwapRoute(routeType, percentToQuotes, percents, swapRouteConfig = {
   minSplits: 1,
   maxSplits: 8
 }) {
-  // Извлекаем уникальные пулы из всех маршрутов
-  const allPools = [...new Set(Object.values(percentToQuotes).flatMap(routes => routes.flatMap(r => r.route.pools)))];
+  const {
+    minSplits,
+    maxSplits,
+    branchFactor = 1,
+    candidateLimit = 0
+  } = swapRouteConfig;
+  const branchWidth = Math.max(1, branchFactor);
+  const quoteCompFn = routeType === _internalConstants.TradeType.EXACT_INPUT ? (a, b) => a.greaterThan(b) : (a, b) => a.lessThan(b);
+  const quoteOf = routeType === _internalConstants.TradeType.EXACT_INPUT ? q => q.outputAmount : q => q.inputAmount;
 
-  // Создаем битовую карту для пулов (bigint для поддержки >31 пулов)
+  // Build pool bit ids without intermediate arrays.
   const poolToBit = new Map();
   let bitCounter = BigInt(0);
-  for (const pool of allPools) {
-    poolToBit.set(pool.id, BigInt(1) << bitCounter++);
+  for (const quotes of Object.values(percentToQuotes)) {
+    for (const quote of quotes) {
+      for (const pool of quote.route.pools) {
+        if (!poolToBit.has(pool.id)) {
+          poolToBit.set(pool.id, BigInt(1) << bitCounter);
+          bitCounter += BigInt(1);
+        }
+      }
+    }
   }
-
-  // Предвычисляем маски для всех маршрутов
   const routeToMask = new Map();
-  for (const routes of Object.values(percentToQuotes)) {
-    for (const route of routes) {
+  for (const quotes of Object.values(percentToQuotes)) {
+    for (const quote of quotes) {
       let mask = BigInt(0);
-      for (const pool of route.route.pools) {
+      for (const pool of quote.route.pools) {
         mask |= poolToBit.get(pool.id);
       }
-      routeToMask.set(route, mask);
+      routeToMask.set(quote, mask);
     }
   }
-
-  // Сортируем маршруты для каждого процента
   const percentToSortedQuotes = {};
   for (const percent in percentToQuotes) {
-    percentToSortedQuotes[percent] = percentToQuotes[percent].sort((a, b) => routeType === _internalConstants.TradeType.EXACT_INPUT ? a.outputAmount.greaterThan(b.outputAmount) ? -1 : 1 : a.inputAmount.lessThan(b.inputAmount) ? -1 : 1);
+    const sorted = percentToQuotes[percent].sort((a, b) => {
+      const qa = quoteOf(a);
+      const qb = quoteOf(b);
+      return quoteCompFn(qa, qb) ? -1 : 1;
+    });
+    percentToSortedQuotes[percent] = candidateLimit > 0 && sorted.length > candidateLimit ? sorted.slice(0, candidateLimit) : sorted;
   }
-
-  // Функция сравнения для типа торговли
-  const quoteCompFn = routeType === _internalConstants.TradeType.EXACT_INPUT ? (a, b) => a.greaterThan(b) : (a, b) => a.lessThan(b);
-
-  // Функция суммирования CurrencyAmount
-  const sumFn = currencyAmounts => {
-    let sum = currencyAmounts[0];
-    for (let i = 1; i < currencyAmounts.length; i++) {
-      sum = sum.add(currencyAmounts[i]);
-    }
-    return sum;
-  };
   let bestQuote;
   let bestSwap;
-
-  // Храним лучшие маршруты для каждого уровня разбиения (максимум 3)
-  const bestSwapsPerSplit = new _fixedReverseHeap.default(Array, (a, b) => quoteCompFn(a.quote, b.quote) ? -1 : 1, 3);
-  const {
-    minSplits,
-    maxSplits
-  } = swapRouteConfig;
-
-  // Проверяем наличие маршрута для 100% и инициализируем начальные данные
-  if (!percentToSortedQuotes[100] || percentToSortedQuotes[100].length === 0 || minSplits > 1) {
+  if ((!percentToSortedQuotes[100] || percentToSortedQuotes[100].length === 0) && minSplits <= 1) {
     console.log('Did not find a valid route without any splits. Continuing search anyway.');
-  } else {
-    bestQuote = percentToSortedQuotes[100][0].outputAmount;
+  } else if (minSplits <= 1 && percentToSortedQuotes[100] && percentToSortedQuotes[100][0]) {
     bestSwap = [percentToSortedQuotes[100][0]];
-    for (const routeWithQuote of percentToSortedQuotes[100].slice(0, 5)) {
-      bestSwapsPerSplit.push({
-        quote: routeWithQuote.outputAmount,
-        routes: [routeWithQuote]
-      });
-    }
+    bestQuote = quoteOf(percentToSortedQuotes[100][0]);
   }
-
-  // Очередь для обработки комбинаций маршрутов (с usedMask для быстрой проверки overlap)
   const queue = new _queue.default();
   if (percents.length === 0) return null;
-
-  // Инициализируем очередь с топ-2 маршрутами для каждого процента
   for (let i = percents.length - 1; i >= 0; i--) {
     const percent = percents[i];
-    if (!percentToSortedQuotes[percent] || percentToSortedQuotes[percent].length === 0) continue;
-    const topRoutes = percentToSortedQuotes[percent].slice(0, 2);
-    if (topRoutes[0]) {
+    const candidates = percentToSortedQuotes[percent];
+    if (!candidates || candidates.length === 0) continue;
+    const seeds = candidates.slice(0, branchWidth);
+    for (const seed of seeds) {
       queue.enqueue({
-        curRoutes: [topRoutes[0]],
+        curRoutes: [seed],
         percentIndex: i,
         remainingPercent: 100 - percent,
-        usedMask: routeToMask.get(topRoutes[0]),
-        special: false
-      });
-    }
-    if (topRoutes[1]) {
-      queue.enqueue({
-        curRoutes: [topRoutes[1]],
-        percentIndex: i,
-        remainingPercent: 100 - percent,
-        usedMask: routeToMask.get(topRoutes[1]),
-        special: true
+        usedMask: routeToMask.get(seed),
+        quoteSoFar: quoteOf(seed)
       });
     }
   }
   let splits = 1;
-
-  // Основной цикл поиска лучших маршрутов
   while (queue.size > 0) {
-    bestSwapsPerSplit.clear();
     let layer = queue.size;
     splits++;
     if (splits >= 3 && bestSwap && bestSwap.length < splits - 1) {
@@ -123,38 +95,37 @@ function getBestSwapRoute(routeType, percentToQuotes, percents, swapRouteConfig
         curRoutes,
         percentIndex,
         usedMask,
-        special
+        quoteSoFar
       } = queue.dequeue();
       for (let i = percentIndex; i >= 0; i--) {
-        const percentA = percents[i];
-        if (percentA > remainingPercent) continue;
-        if (!percentToSortedQuotes[percentA] || percentToSortedQuotes[percentA].length === 0) continue;
-        const candidateRoutesA = percentToSortedQuotes[percentA];
-        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);
-          bestSwapsPerSplit.push({
-            quote: quoteNew,
-            routes: curRoutesNew
-          });
-          if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
-            bestQuote = quoteNew;
-            bestSwap = curRoutesNew;
+        const percent = percents[i];
+        if (percent > remainingPercent) continue;
+        const candidates = percentToSortedQuotes[percent];
+        if (!candidates || candidates.length === 0) continue;
+        const routeCandidates = findRoutesNotUsingUsedPools(usedMask, candidates, routeToMask, branchWidth);
+        if (routeCandidates.length === 0) continue;
+        for (const candidate of routeCandidates) {
+          const remainingPercentNew = remainingPercent - percent;
+          const usedMaskNew = usedMask | routeToMask.get(candidate);
+          const quoteNew = quoteSoFar.add(quoteOf(candidate));
+          if (remainingPercentNew === 0 && splits >= minSplits) {
+            const curRoutesNew = curRoutes.slice();
+            curRoutesNew.push(candidate);
+            if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
+              bestQuote = quoteNew;
+              bestSwap = curRoutesNew;
+            }
+          } else {
+            const curRoutesNew = curRoutes.slice();
+            curRoutesNew.push(candidate);
+            queue.enqueue({
+              curRoutes: curRoutesNew,
+              remainingPercent: remainingPercentNew,
+              percentIndex: i,
+              usedMask: usedMaskNew,
+              quoteSoFar: quoteNew
+            });
           }
-        } else {
-          queue.enqueue({
-            curRoutes: curRoutesNew,
-            remainingPercent: remainingPercentNew,
-            percentIndex: i,
-            usedMask: usedMaskNew,
-            special
-          });
         }
       }
     }
@@ -163,18 +134,16 @@ function getBestSwapRoute(routeType, percentToQuotes, percents, swapRouteConfig
     console.log('Could not find a valid swap');
     return null;
   }
-  const quote = sumFn(bestSwap.map(routeWithValidQuote => routeWithValidQuote.outputAmount));
-  const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) => routeAmountB.outputAmount.greaterThan(routeAmountA.outputAmount) ? 1 : -1);
-  return routeWithQuotes;
+  return bestSwap;
 }
-
-// Вспомогательная функция для поиска маршрута без пересекающихся пулов
-const findFirstRouteNotUsingUsedPools = (usedMask, candidateRoutes, routeToMask) => {
+const findRoutesNotUsingUsedPools = (usedMask, candidateRoutes, routeToMask, limit) => {
+  const result = [];
   for (const candidate of candidateRoutes) {
     const candidateMask = routeToMask.get(candidate);
     if ((candidateMask & usedMask) === BigInt(0)) {
-      return candidate;
+      result.push(candidate);
+      if (result.length >= limit) return result;
     }
   }
-  return null;
+  return result;
 };

package/build/utils/tradeCalculatorWASM.d.ts

@@ -26,7 +26,7 @@ export declare class WASMTradeCalculator {
         amountIn: CurrencyAmount<Token>;
         amountOut: CurrencyAmount<Token>;
         priceImpact: number;
-    }>;
+    } | null>;
     /**
      * Clear all pools from memory
      */

package/build/utils/tradeCalculatorWASM.js

@@ -9,6 +9,7 @@ exports.createTradeFromRouteWASM = createTradeFromRouteWASM;
 var _entities = require("../entities");
 var _fractions = require("../entities/fractions");
 var _internalConstants = require("../internalConstants");
+var _getBestSwapRoute = require("./getBestSwapRoute");
 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; }
@@ -153,6 +154,8 @@ let WASMTradeCalculator = exports.WASMTradeCalculator = /*#__PURE__*/function ()
               amountOut: _fractions.CurrencyAmount.fromRawAmount(route.output, BigInt(result.amountOut)),
               priceImpact: result.priceImpact
             });
+          } else {
+            trades.push(null);
           }
         }
       }
@@ -218,37 +221,34 @@ async function bestTradeWithSplitWASM(routes, amount, percents, tradeType, pools
     const allTrades = calculator.calculateTradesBatch(routes, splitAmounts);
 
     // Group trades by percent
-    const tradesByPercent = {};
-    let tradeIdx = 0;
+    const quotesByPercent = {};
     for (let i = 0; i < percents.length; i++) {
       const percent = percents[i];
-      tradesByPercent[percent] = [];
-      for (const route of routes) {
-        const tradeDat = allTrades[tradeIdx++];
+      quotesByPercent[percent] = [];
+    }
+    const amountsPerRoute = splitAmounts.length;
+    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
+      for (let percentIndex = 0; percentIndex < percents.length; percentIndex++) {
+        const flatIndex = routeIndex * amountsPerRoute + percentIndex;
+        const tradeDat = allTrades[flatIndex];
         if (tradeDat) {
-          const trade = _entities.Trade.createUncheckedTrade({
+          const percent = percents[percentIndex];
+          quotesByPercent[percent].push({
             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);
+    const bestTrades = (0, _getBestSwapRoute.getBestSwapRoute)(tradeType, quotesByPercent, 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
+      percent: trade.percent
     }));
     return _entities.Trade.createUncheckedTradeWithMultipleRoutes({
       routes: routeData,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "",
   "main": "build/index.js",
   "module": "build/esm/index.js",