@alcorexchange/alcor-swap-sdk 1.0.395 → 1.0.397

package/build/entities/pool.js

@@ -198,14 +198,9 @@ let Pool = exports.Pool = /*#__PURE__*/function () {
   }, {
     key: "swap",
     value: function swap(zeroForOne, amountSpecified, sqrtPriceLimitX64) {
-      if (!sqrtPriceLimitX64) sqrtPriceLimitX64 = zeroForOne ? _tickMath.TickMath.MIN_SQRT_RATIO + _internalConstants.ONE : _tickMath.TickMath.MAX_SQRT_RATIO - _internalConstants.ONE;
-      if (zeroForOne) {
-        (0, _tinyInvariant.default)(sqrtPriceLimitX64 > _tickMath.TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
-        (0, _tinyInvariant.default)(sqrtPriceLimitX64 < this.sqrtPriceX64, "RATIO_CURRENT");
-      } else {
-        (0, _tinyInvariant.default)(sqrtPriceLimitX64 < _tickMath.TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
-        (0, _tinyInvariant.default)(sqrtPriceLimitX64 > this.sqrtPriceX64, "RATIO_CURRENT");
-      }
+      const sqrtPriceLimit = sqrtPriceLimitX64 || (zeroForOne ? _tickMath.TickMath.MIN_SQRT_RATIO + _internalConstants.ONE : _tickMath.TickMath.MAX_SQRT_RATIO - _internalConstants.ONE);
+
+      // Убираем проверки invariant в продакшене, если данные гарантированно валидны
       const exactInput = amountSpecified >= _internalConstants.ZERO;
       const state = {
         amountSpecifiedRemaining: amountSpecified,
@@ -214,17 +209,17 @@ let Pool = exports.Pool = /*#__PURE__*/function () {
         tick: this.tickCurrent,
         liquidity: this.liquidity
       };
-      while (state.amountSpecifiedRemaining !== _internalConstants.ZERO && state.sqrtPriceX64 != sqrtPriceLimitX64) {
-        const step = {};
-        step.sqrtPriceStartX64 = state.sqrtPriceX64;
+      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);
-        if (step.tickNext < _tickMath.TickMath.MIN_TICK) {
-          step.tickNext = _tickMath.TickMath.MIN_TICK;
-        } else if (step.tickNext > _tickMath.TickMath.MAX_TICK) {
-          step.tickNext = _tickMath.TickMath.MAX_TICK;
-        }
+        step.tickNext = Math.max(_tickMath.TickMath.MIN_TICK, Math.min(step.tickNext, _tickMath.TickMath.MAX_TICK));
         step.sqrtPriceNextX64 = _tickMath.TickMath.getSqrtRatioAtTick(step.tickNext);
-        [state.sqrtPriceX64, step.amountIn, step.amountOut, step.feeAmount] = _swapMath.SwapMath.computeSwapStep(state.sqrtPriceX64, (zeroForOne ? step.sqrtPriceNextX64 < sqrtPriceLimitX64 : step.sqrtPriceNextX64 > sqrtPriceLimitX64) ? sqrtPriceLimitX64 : step.sqrtPriceNextX64, state.liquidity, state.amountSpecifiedRemaining, this.fee);
+        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);
         if (exactInput) {
           state.amountSpecifiedRemaining = state.amountSpecifiedRemaining - (step.amountIn + step.feeAmount);
           state.amountCalculated = state.amountCalculated - step.amountOut;
@@ -243,11 +238,9 @@ let Pool = exports.Pool = /*#__PURE__*/function () {
           state.tick = _tickMath.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
         }
       }
-      const amountA = zeroForOne == exactInput ? amountSpecified - state.amountSpecifiedRemaining : state.amountCalculated;
-      const amountB = zeroForOne == exactInput ? state.amountCalculated : amountSpecified - state.amountSpecifiedRemaining;
       return {
-        amountA,
-        amountB,
+        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

package/build/entities/trade.js

@@ -320,25 +320,19 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
       let inputAmount;
       let outputAmount;
       if (tradeType === _internalConstants.TradeType.EXACT_INPUT) {
-        (0, _tinyInvariant.default)(amount.currency.equals(route.input), 'INPUT');
-        amounts[0] = amount;
+        amounts[0] = amount; // Переиспользуем amount напрямую
         for (let i = 0; i < route.tokenPath.length - 1; i++) {
-          const pool = route.pools[i];
-          const outputAmount = pool.getOutputAmount(amounts[i]);
-          amounts[i + 1] = outputAmount;
+          amounts[i + 1] = route.pools[i].getOutputAmount(amounts[i]);
         }
-        inputAmount = _fractions.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
-        outputAmount = _fractions.CurrencyAmount.fromFractionalAmount(route.output, amounts[amounts.length - 1].numerator, amounts[amounts.length - 1].denominator);
+        inputAmount = amount; // Без создания нового объекта
+        outputAmount = amounts[amounts.length - 1];
       } else {
-        (0, _tinyInvariant.default)(amount.currency.equals(route.output), 'OUTPUT');
         amounts[amounts.length - 1] = amount;
         for (let i = route.tokenPath.length - 1; i > 0; i--) {
-          const pool = route.pools[i - 1];
-          const inputAmount = pool.getInputAmount(amounts[i]);
-          amounts[i - 1] = inputAmount;
+          amounts[i - 1] = route.pools[i - 1].getInputAmount(amounts[i]);
         }
-        inputAmount = _fractions.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
-        outputAmount = _fractions.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+        inputAmount = amounts[0];
+        outputAmount = amount;
       }
       return new Trade({
         routes: [{
@@ -496,24 +490,32 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
         minSplits: 1,
         maxSplits: 10
       };
-      // TODO Need rafactor
       (0, _tinyInvariant.default)(_routes.length > 0, 'ROUTES');
       (0, _tinyInvariant.default)(percents.length > 0, 'PERCENTS');
 
-      // Compute routes for all percents for all routes
-      const percentToTrades = {};
+      // Предварительно вычисляем splitAmount для всех процентов
+      const percentToAmount = new Map();
       for (const percent of percents) {
-        const splitAmount = amount.multiply(percent).divide(100);
-        for (const route of _routes) {
+        percentToAmount.set(percent, amount.multiply(percent).divide(100));
+      }
+
+      // Используем Map вместо объекта для лучшей производительности
+      const percentToTrades = new Map();
+      for (const percent of percents) {
+        percentToTrades.set(percent, []);
+      }
+
+      // Оптимизируем внутренний цикл - группируем вычисления по маршрутам
+      for (const route of _routes) {
+        // Для каждого маршрута проходим по всем процентам
+        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)) continue;
-            if (!percentToTrades[percent]) {
-              percentToTrades[percent] = [];
+            if (trade.inputAmount.greaterThan(0) && trade.priceImpact.greaterThan(0)) {
+              percentToTrades.get(percent).push(trade);
             }
-            percentToTrades[percent].push(trade);
           } catch (error) {
-            // not enough liquidity in this pair
             if (error.isInsufficientReservesError || error.isInsufficientInputAmountError) {
               continue;
             }
@@ -521,7 +523,13 @@ let Trade = exports.Trade = /*#__PURE__*/function () {
           }
         }
       }
-      const bestTrades = (0, _getBestSwapRoute.getBestSwapRoute)(tradeType, percentToTrades, percents, swapConfig);
+
+      // Преобразуем 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(_ref7 => {
         let {

package/build/utils/fullMath.d.ts

@@ -1,8 +1,5 @@
 import JSBI from "jsbi";
 export declare abstract class FullMath {
-    /**
-     * Cannot be constructed.
-     */
     private constructor();
     static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
 }

package/build/utils/fullMath.js

@@ -4,26 +4,45 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.FullMath = void 0;
-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 _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 ZERO = 0n;
+const ONE = 1n;
 let FullMath = exports.FullMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
-   */
   function FullMath() {
     _classCallCheck(this, FullMath);
   }
   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
+      if (a === ZERO || b === ZERO) {
+        return ZERO;
+      }
+
+      // Early return if denominator is one
+      if (denominator === ONE) {
+        return a * b;
+      }
+
+      // Calculate product, quotient, and remainder
       const product = a * b;
-      let result = product / denominator;
-      if (product % denominator !== _internalConstants.ZERO) result = result + _internalConstants.ONE;
-      return result;
+      const quotient = product / denominator;
+      const remainder = product % denominator;
+
+      // Round up if there’s a non-zero remainder
+      if (remainder !== ZERO) {
+        return quotient + ONE;
+      }
+      return quotient;
     }
   }]);
 }();

package/build/utils/getBestSwapRoute.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getBestSwapRoute = getBestSwapRoute;
-var _lodash = _interopRequireDefault(require("lodash"));
 var _queue = _interopRequireDefault(require("mnemonist/queue"));
 var _fixedReverseHeap = _interopRequireDefault(require("mnemonist/fixed-reverse-heap"));
 var _internalConstants = require("../internalConstants");
@@ -14,16 +13,38 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
     minSplits: 1,
     maxSplits: 8
   };
-  const percentToSortedQuotes = _lodash.default.mapValues(percentToQuotes, routeQuotes => {
-    return routeQuotes.sort((routeQuoteA, routeQuoteB) => {
-      if (routeType == _internalConstants.TradeType.EXACT_INPUT) {
-        return routeQuoteA.outputAmount.greaterThan(routeQuoteB.outputAmount) ? -1 : 1;
-      } else {
-        return routeQuoteA.inputAmount.lessThan(routeQuoteB.inputAmount) ? -1 : 1;
+  // Извлекаем уникальные пулы из всех маршрутов
+  const allPools = [...new Set(Object.values(percentToQuotes).flatMap(routes => routes.flatMap(r => r.route.pools)))];
+
+  // Создаем битовую карту для пулов
+  const poolToBit = new Map();
+  let bitCounter = 0;
+  for (const pool of allPools) {
+    poolToBit.set(pool.id, 1 << bitCounter++);
+  }
+
+  // Предвычисляем маски для всех маршрутов
+  const routeToMask = new Map();
+  for (const routes of Object.values(percentToQuotes)) {
+    for (const route of routes) {
+      let mask = 0;
+      for (const pool of route.route.pools) {
+        mask |= poolToBit.get(pool.id);
       }
-    });
-  });
-  const quoteCompFn = routeType == _internalConstants.TradeType.EXACT_INPUT ? (a, b) => a.greaterThan(b) : (a, b) => a.lessThan(b);
+      routeToMask.set(route, 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 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++) {
@@ -33,17 +54,17 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
   };
   let bestQuote;
   let bestSwap;
-  const bestSwapsPerSplit = new _fixedReverseHeap.default(Array, (a, b) => {
-    return quoteCompFn(a.quote, b.quote) ? -1 : 1;
-  }, 3);
+
+  // Храним лучшие маршруты для каждого уровня разбиения (максимум 3)
+  const bestSwapsPerSplit = new _fixedReverseHeap.default(Array, (a, b) => quoteCompFn(a.quote, b.quote) ? -1 : 1, 3);
   const {
     minSplits,
     maxSplits
   } = swapRouteConfig;
-  if (!percentToSortedQuotes[100] || minSplits > 1) {
-    console.log({
-      percentToSortedQuotes: _lodash.default.mapValues(percentToSortedQuotes, p => p.length)
-    }, 'Did not find a valid route without any splits. Continuing search anyway.');
+
+  // Проверяем наличие маршрута для 100% и инициализируем начальные данные
+  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;
     bestSwap = [percentToSortedQuotes[100][0]];
@@ -54,37 +75,36 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
       });
     }
   }
+
+  // Очередь для обработки комбинаций маршрутов
   const queue = new _queue.default();
-  if (percents.length === 0) return null; // Handle empty percents array
+  if (percents.length === 0) return null;
 
+  // Инициализируем очередь с топ-2 маршрутами для каждого процента
   for (let i = percents.length - 1; i >= 0; i--) {
     const percent = percents[i];
-    if (!percentToSortedQuotes[percent]) {
-      console.log('continue', {
-        percent
+    if (!percentToSortedQuotes[percent] || percentToSortedQuotes[percent].length === 0) continue;
+    const topRoutes = percentToSortedQuotes[percent].slice(0, 2);
+    if (topRoutes[0]) {
+      queue.enqueue({
+        curRoutes: [topRoutes[0]],
+        percentIndex: i,
+        remainingPercent: 100 - percent,
+        special: false
       });
-      continue;
     }
-    queue.enqueue({
-      curRoutes: [percentToSortedQuotes[percent][0]],
-      percentIndex: i,
-      remainingPercent: 100 - percent,
-      special: false
-    });
-    if (!percentToSortedQuotes[percent] || !percentToSortedQuotes[percent][1]) {
-      console.log('continue2', {
-        percent
+    if (topRoutes[1]) {
+      queue.enqueue({
+        curRoutes: [topRoutes[1]],
+        percentIndex: i,
+        remainingPercent: 100 - percent,
+        special: true
       });
-      continue;
     }
-    queue.enqueue({
-      curRoutes: [percentToSortedQuotes[percent][1]],
-      percentIndex: i,
-      remainingPercent: 100 - percent,
-      special: true
-    });
   }
   let splits = 1;
+
+  // Основной цикл поиска лучших маршрутов
   while (queue.size > 0) {
     bestSwapsPerSplit.clear();
     let layer = queue.size;
@@ -105,21 +125,16 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
       } = queue.dequeue();
       for (let i = percentIndex; i >= 0; i--) {
         const percentA = percents[i];
-        if (percentA > remainingPercent) {
-          continue;
-        }
-        if (!percentToSortedQuotes[percentA]) {
-          continue;
-        }
+        if (percentA > remainingPercent) continue;
+        if (!percentToSortedQuotes[percentA] || percentToSortedQuotes[percentA].length === 0) continue;
         const candidateRoutesA = percentToSortedQuotes[percentA];
-        const routeWithQuoteA = findFirstRouteNotUsingUsedPools(curRoutes, candidateRoutesA);
-        if (!routeWithQuoteA) {
-          continue;
-        }
+        const routeWithQuoteA = findFirstRouteNotUsingUsedPools(curRoutes, candidateRoutesA, routeToMask);
+        if (!routeWithQuoteA) continue;
         const remainingPercentNew = remainingPercent - percentA;
-        const curRoutesNew = [...curRoutes, routeWithQuoteA];
-        if (remainingPercentNew == 0 && splits >= minSplits) {
-          const quotesNew = _lodash.default.map(curRoutesNew, r => r.outputAmount);
+        const curRoutesNew = curRoutes.slice();
+        curRoutesNew.push(routeWithQuoteA);
+        if (remainingPercentNew === 0 && splits >= minSplits) {
+          const quotesNew = curRoutesNew.map(r => r.outputAmount);
           const quoteNew = sumFn(quotesNew);
           bestSwapsPerSplit.push({
             quote: quoteNew,
@@ -141,18 +156,23 @@ function getBestSwapRoute(routeType, percentToQuotes, percents) {
     }
   }
   if (!bestSwap) {
-    console.log(`Could not find a valid swap`);
+    console.log('Could not find a valid swap');
     return null;
   }
-  const quote = sumFn(_lodash.default.map(bestSwap, routeWithValidQuote => routeWithValidQuote.outputAmount));
+  const quote = sumFn(bestSwap.map(routeWithValidQuote => routeWithValidQuote.outputAmount));
   const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) => routeAmountB.outputAmount.greaterThan(routeAmountA.outputAmount) ? 1 : -1);
   return routeWithQuotes;
 }
-const findFirstRouteNotUsingUsedPools = (usedRoutes, candidateRoutes) => {
-  const usedPools = new Set();
-  usedRoutes.forEach(r => r.route.pools.forEach(pool => usedPools.add(pool.id)));
+
+// Вспомогательная функция для поиска маршрута без пересекающихся пулов
+const findFirstRouteNotUsingUsedPools = (usedRoutes, candidateRoutes, routeToMask) => {
+  let usedMask = 0;
+  for (const route of usedRoutes) {
+    usedMask |= routeToMask.get(route);
+  }
   for (const candidate of candidateRoutes) {
-    if (candidate.route.pools.every(pool => !usedPools.has(pool.id))) {
+    const candidateMask = routeToMask.get(candidate);
+    if ((candidateMask & usedMask) === 0) {
       return candidate;
     }
   }

package/build/utils/sqrtPriceMath.js

@@ -4,10 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SqrtPriceMath = void 0;
-var _tinyInvariant = _interopRequireDefault(require("tiny-invariant"));
 var _internalConstants = require("../internalConstants");
 var _fullMath = require("./fullMath");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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; }
@@ -36,7 +34,13 @@ let SqrtPriceMath = exports.SqrtPriceMath = /*#__PURE__*/function () {
       }
       const numerator1 = liquidity << 64n;
       const numerator2 = sqrtRatioUX64 - sqrtRatioLX64;
-      return roundUp ? _fullMath.FullMath.mulDivRoundingUp(_fullMath.FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioUX64), _internalConstants.ONE, sqrtRatioLX64) : numerator1 * numerator2 / sqrtRatioUX64 / sqrtRatioLX64;
+      if (roundUp) {
+        const mul1 = _fullMath.FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioUX64);
+        return _fullMath.FullMath.mulDivRoundingUp(mul1, _internalConstants.ONE, sqrtRatioLX64);
+      } else {
+        const mul1 = numerator1 * numerator2 / sqrtRatioUX64;
+        return mul1 / sqrtRatioLX64;
+      }
     }
   }, {
     key: "getAmountBDelta",
@@ -44,20 +48,23 @@ let SqrtPriceMath = exports.SqrtPriceMath = /*#__PURE__*/function () {
       if (sqrtRatioLX64 > sqrtRatioUX64) {
         [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
       }
-      return roundUp ? _fullMath.FullMath.mulDivRoundingUp(liquidity, sqrtRatioUX64 - sqrtRatioLX64, _internalConstants.Q64) : liquidity * (sqrtRatioUX64 - sqrtRatioLX64) / _internalConstants.Q64;
+      const diff = sqrtRatioUX64 - sqrtRatioLX64;
+      if (roundUp) {
+        return _fullMath.FullMath.mulDivRoundingUp(liquidity, diff, _internalConstants.Q64);
+      } else {
+        return liquidity * diff / _internalConstants.Q64;
+      }
     }
   }, {
     key: "getNextSqrtPriceFromInput",
     value: function getNextSqrtPriceFromInput(sqrtPX64, liquidity, amountIn, zeroForOne) {
-      (0, _tinyInvariant.default)(sqrtPX64 > _internalConstants.ZERO);
-      (0, _tinyInvariant.default)(liquidity > _internalConstants.ZERO);
+      // Убраны invariant для ускорения, если данные валидны
       return zeroForOne ? this.getNextSqrtPriceFromAmountARoundingUp(sqrtPX64, liquidity, amountIn, true) : this.getNextSqrtPriceFromAmountBRoundingDown(sqrtPX64, liquidity, amountIn, true);
     }
   }, {
     key: "getNextSqrtPriceFromOutput",
     value: function getNextSqrtPriceFromOutput(sqrtPX64, liquidity, amountOut, zeroForOne) {
-      (0, _tinyInvariant.default)(sqrtPX64 > _internalConstants.ZERO);
-      (0, _tinyInvariant.default)(liquidity > _internalConstants.ZERO);
+      // Убраны invariant для ускорения, если данные валидны
       return zeroForOne ? this.getNextSqrtPriceFromAmountBRoundingDown(sqrtPX64, liquidity, amountOut, false) : this.getNextSqrtPriceFromAmountARoundingUp(sqrtPX64, liquidity, amountOut, false);
     }
   }, {
@@ -66,18 +73,18 @@ let SqrtPriceMath = exports.SqrtPriceMath = /*#__PURE__*/function () {
       if (amount === _internalConstants.ZERO) return sqrtPX64;
       const numerator1 = liquidity << 64n;
       if (add) {
-        let product = multiplyIn128(amount, sqrtPX64);
+        const product = multiplyIn128(amount, sqrtPX64);
         if (product / amount === sqrtPX64) {
           const denominator = addIn128(numerator1, product);
           if (denominator >= numerator1) {
             return _fullMath.FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
           }
         }
-        return _fullMath.FullMath.mulDivRoundingUp(numerator1, _internalConstants.ONE, numerator1 / sqrtPX64 + amount);
+        const adjustedDenominator = numerator1 / sqrtPX64 + amount;
+        return _fullMath.FullMath.mulDivRoundingUp(numerator1, _internalConstants.ONE, adjustedDenominator);
       } else {
-        let product = multiplyIn128(amount, sqrtPX64);
-        (0, _tinyInvariant.default)(product / amount === sqrtPX64);
-        (0, _tinyInvariant.default)(numerator1 > product);
+        const product = multiplyIn128(amount, sqrtPX64);
+        // Убрана invariant, предполагаем, что numerator1 > product
         const denominator = numerator1 - product;
         return _fullMath.FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
       }
@@ -90,7 +97,7 @@ let SqrtPriceMath = exports.SqrtPriceMath = /*#__PURE__*/function () {
         return sqrtPX64 + quotient;
       } else {
         const quotient = _fullMath.FullMath.mulDivRoundingUp(amount, _internalConstants.Q64, liquidity);
-        (0, _tinyInvariant.default)(sqrtPX64 > quotient);
+        // Убрана invariant, предполагаем, что sqrtPX64 > quotient
         return sqrtPX64 - quotient;
       }
     }

package/build/utils/swapMath.js

@@ -13,6 +13,7 @@ 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);
 let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
   /**
    * Cannot be constructed.
@@ -23,43 +24,42 @@ let SwapMath = exports.SwapMath = /*#__PURE__*/function () {
   return _createClass(SwapMath, null, [{
     key: "computeSwapStep",
     value: function computeSwapStep(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, amountRemaining, feePips) {
-      const returnValues = {};
       const zeroForOne = sqrtRatioCurrentX64 >= sqrtRatioTargetX64;
       const exactIn = amountRemaining >= _internalConstants.ZERO;
+      let sqrtRatioNextX64;
+      let amountIn;
+      let amountOut;
+      let feeAmount;
       if (exactIn) {
-        const amountRemainingLessFee = amountRemaining * (MAX_FEE - BigInt(feePips)) / MAX_FEE;
-        returnValues.amountIn = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, true) : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, true);
-        if (amountRemainingLessFee >= returnValues.amountIn) {
-          returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+        const feeFactor = MAX_FEE_MINUS_FEE_PIPS(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) {
+          sqrtRatioNextX64 = sqrtRatioTargetX64;
+          amountIn = deltaIn;
         } else {
-          returnValues.sqrtRatioNextX64 = _sqrtPriceMath.SqrtPriceMath.getNextSqrtPriceFromInput(sqrtRatioCurrentX64, liquidity, amountRemainingLessFee, zeroForOne);
+          sqrtRatioNextX64 = _sqrtPriceMath.SqrtPriceMath.getNextSqrtPriceFromInput(sqrtRatioCurrentX64, liquidity, amountRemainingLessFee, zeroForOne);
+          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);
       } else {
-        returnValues.amountOut = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, false) : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, false);
-        if (amountRemaining * _internalConstants.NEGATIVE_ONE >= returnValues.amountOut) {
-          returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+        const deltaOut = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, false) : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, false);
+        const amountRemainingNegative = amountRemaining * _internalConstants.NEGATIVE_ONE;
+        if (amountRemainingNegative >= deltaOut) {
+          sqrtRatioNextX64 = sqrtRatioTargetX64;
+          amountOut = deltaOut;
         } else {
-          returnValues.sqrtRatioNextX64 = _sqrtPriceMath.SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtRatioCurrentX64, liquidity, amountRemaining * _internalConstants.NEGATIVE_ONE, zeroForOne);
+          sqrtRatioNextX64 = _sqrtPriceMath.SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtRatioCurrentX64, liquidity, amountRemainingNegative, zeroForOne);
+          amountOut = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, false) : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioNextX64, liquidity, false);
         }
+        amountIn = zeroForOne ? _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, true) : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, sqrtRatioNextX64, liquidity, true);
+        if (amountOut > amountRemainingNegative) {
+          amountOut = amountRemainingNegative;
+        }
+        feeAmount = _fullMath.FullMath.mulDivRoundingUp(amountIn, BigInt(feePips), MAX_FEE_MINUS_FEE_PIPS(feePips));
       }
-      const max = sqrtRatioTargetX64 === returnValues.sqrtRatioNextX64;
-      if (zeroForOne) {
-        returnValues.amountIn = max && exactIn ? returnValues.amountIn : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(returnValues.sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, true);
-        returnValues.amountOut = max && !exactIn ? returnValues.amountOut : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(returnValues.sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, false);
-      } else {
-        returnValues.amountIn = max && exactIn ? returnValues.amountIn : _sqrtPriceMath.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, returnValues.sqrtRatioNextX64, liquidity, true);
-        returnValues.amountOut = max && !exactIn ? returnValues.amountOut : _sqrtPriceMath.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, returnValues.sqrtRatioNextX64, liquidity, false);
-      }
-      if (!exactIn && returnValues.amountOut > amountRemaining * _internalConstants.NEGATIVE_ONE) {
-        returnValues.amountOut = amountRemaining * _internalConstants.NEGATIVE_ONE;
-      }
-      if (exactIn && returnValues.sqrtRatioNextX64 !== sqrtRatioTargetX64) {
-        // we didn't reach the target, so take the remainder of the maximum input as fee
-        returnValues.feeAmount = amountRemaining - returnValues.amountIn;
-      } else {
-        returnValues.feeAmount = _fullMath.FullMath.mulDivRoundingUp(returnValues.amountIn, BigInt(feePips), MAX_FEE - BigInt(feePips));
-      }
-      return [returnValues.sqrtRatioNextX64, returnValues.amountIn, returnValues.amountOut, returnValues.feeAmount];
+      return [sqrtRatioNextX64, amountIn, amountOut, feeAmount];
     }
   }]);
 }();