@alcorexchange/alcor-swap-sdk 1.0.33 → 1.0.35

package/build/entities/pool.js

@@ -17,6 +17,7 @@ const swapMath_1 = require("../utils/swapMath");
 const tickMath_1 = require("../utils/tickMath");
 const tickDataProvider_1 = require("./tickDataProvider");
 const tickListDataProvider_1 = require("./tickListDataProvider");
+const errors_1 = require("../errors");
 /**
  * By default, pools will not allow operations that require ticks.
  */
@@ -97,8 +98,14 @@ class Pool {
     getOutputAmount(inputAmount, sqrtPriceLimitX64) {
         (0, tiny_invariant_1.default)(this.involvesToken(inputAmount.currency), "TOKEN");
         const zeroForOne = inputAmount.currency.equals(this.tokenA);
-        const { amountCalculated: outputAmount, } = this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
+        const { amountA, amountB } = this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
         const outputToken = zeroForOne ? this.tokenB : this.tokenA;
+        const outputAmount = zeroForOne ? amountB : amountA;
+        const amountIn = zeroForOne ? amountA : amountB;
+        //console.log(JSBI.equal(amountIn, inputAmount.quotient))
+        if (!jsbi_1.default.equal(amountIn, inputAmount.quotient)) {
+            throw new errors_1.InsufficientInputAmountError;
+        }
         return fractions_1.CurrencyAmount.fromRawAmount(outputToken, jsbi_1.default.multiply(outputAmount, internalConstants_2.NEGATIVE_ONE));
     }
     /**
@@ -109,8 +116,13 @@ class Pool {
      */
     getInputAmount(outputAmount, sqrtPriceLimitX64) {
         const zeroForOne = outputAmount.currency.equals(this.tokenB);
-        const { amountCalculated: inputAmount, } = this.swap(zeroForOne, jsbi_1.default.multiply(outputAmount.quotient, internalConstants_2.NEGATIVE_ONE), sqrtPriceLimitX64);
+        const { amountA, amountB } = this.swap(zeroForOne, jsbi_1.default.multiply(outputAmount.quotient, internalConstants_2.NEGATIVE_ONE), sqrtPriceLimitX64);
         const inputToken = zeroForOne ? this.tokenA : this.tokenB;
+        const inputAmount = zeroForOne ? amountA : amountB;
+        const amountOutReceived = jsbi_1.default.multiply(zeroForOne ? amountB : amountA, internalConstants_2.NEGATIVE_ONE);
+        if (!jsbi_1.default.equal(amountOutReceived, outputAmount.quotient)) {
+            throw new errors_1.InsufficientReservesError;
+        }
         return fractions_1.CurrencyAmount.fromRawAmount(inputToken, inputAmount);
     }
     /**
@@ -137,7 +149,6 @@ class Pool {
             (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
         }
         const exactInput = jsbi_1.default.greaterThanOrEqual(amountSpecified, internalConstants_2.ZERO);
-        // keep track of swap state
         const state = {
             amountSpecifiedRemaining: amountSpecified,
             amountCalculated: internalConstants_2.ZERO,
@@ -145,14 +156,10 @@ class Pool {
             tick: this.tickCurrent,
             liquidity: this.liquidity,
         };
-        // start swap while loop
         while (jsbi_1.default.notEqual(state.amountSpecifiedRemaining, internalConstants_2.ZERO) &&
             state.sqrtPriceX64 != sqrtPriceLimitX64) {
             const step = {};
             step.sqrtPriceStartX64 = state.sqrtPriceX64;
-            // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
-            // by simply traversing to the next available tick, we instead need to exactly replicate
-            // tickBitmap.nextInitializedTickWithinOneWord
             [step.tickNext, step.initialized] =
                 this.tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, this.tickSpacing);
             if (step.tickNext < tickMath_1.TickMath.MIN_TICK) {
@@ -176,13 +183,9 @@ class Pool {
                 state.amountSpecifiedRemaining = jsbi_1.default.add(state.amountSpecifiedRemaining, step.amountOut);
                 state.amountCalculated = jsbi_1.default.add(state.amountCalculated, jsbi_1.default.add(step.amountIn, step.feeAmount));
             }
-            // TODO
             if (jsbi_1.default.equal(state.sqrtPriceX64, step.sqrtPriceNextX64)) {
-                // if the tick is initialized, run the tick transition
                 if (step.initialized) {
                     let liquidityNet = jsbi_1.default.BigInt((this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
-                    // if we're moving leftward, we interpret liquidityNet as the opposite sign
-                    // safe because liquidityNet cannot be type(int128).min
                     if (zeroForOne)
                         liquidityNet = jsbi_1.default.multiply(liquidityNet, internalConstants_2.NEGATIVE_ONE);
                     state.liquidity = liquidityMath_1.LiquidityMath.addDelta(state.liquidity, liquidityNet);
@@ -190,13 +193,18 @@ class Pool {
                 state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
             }
             else if (jsbi_1.default.notEqual(state.sqrtPriceX64, step.sqrtPriceStartX64)) {
-                // updated comparison function
-                // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
                 state.tick = tickMath_1.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
             }
         }
+        const amountA = zeroForOne == exactInput
+            ? jsbi_1.default.subtract(amountSpecified, state.amountSpecifiedRemaining)
+            : state.amountCalculated;
+        const amountB = zeroForOne == exactInput
+            ? state.amountCalculated
+            : jsbi_1.default.subtract(amountSpecified, state.amountSpecifiedRemaining);
         return {
-            amountCalculated: state.amountCalculated,
+            amountA,
+            amountB,
             sqrtPriceX64: state.sqrtPriceX64,
             liquidity: state.liquidity,
             tickCurrent: state.tick,

package/build/entities/trade.d.ts

@@ -42,6 +42,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * make up the trade.
      */
     readonly swaps: {
+        percent: number;
         route: Route<TInput, TOutput>;
         inputAmount: CurrencyAmount<TInput>;
         outputAmount: CurrencyAmount<TOutput>;
@@ -114,7 +115,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @param tradeType whether the trade is an exact input or exact output swap
      * @returns The route
      */
-    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Trade<TInput, TOutput, TTradeType>;
+    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType, percent?: number): Trade<TInput, TOutput, TTradeType>;
     /**
      * Constructs a trade from routes by simulating swaps
      *
@@ -128,6 +129,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(routes: {
         amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
         route: Route<TInput, TOutput>;
+        percent: number;
     }[], tradeType: TTradeType): Trade<TInput, TOutput, TTradeType>;
     /**
      * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
@@ -139,6 +141,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @returns The unchecked trade
      */
     static createUncheckedTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
+        percent: number;
         route: Route<TInput, TOutput>;
         inputAmount: CurrencyAmount<TInput>;
         outputAmount: CurrencyAmount<TOutput>;
@@ -155,6 +158,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      */
     static createUncheckedTradeWithMultipleRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
         routes: {
+            percent: number;
             route: Route<TInput, TOutput>;
             inputAmount: CurrencyAmount<TInput>;
             outputAmount: CurrencyAmount<TOutput>;
@@ -187,4 +191,8 @@ 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>[];
+    static bestTradeWithSplit<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], amount: CurrencyAmount<Currency>, percents: number[], tradeType: TradeType, swapConfig?: {
+        minSplits: number;
+        maxSplits: number;
+    }): Trade<Currency, Currency, TradeType> | null;
 }

package/build/entities/trade.js

@@ -8,6 +8,7 @@ const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
 const fractions_1 = require("./fractions");
 const utils_1 = require("../utils");
 const internalConstants_1 = require("../internalConstants");
+const getBestSwapRoute_1 = require("../utils/getBestSwapRoute");
 /**
  * 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
@@ -154,7 +155,7 @@ class Trade {
      * @param tradeType whether the trade is an exact input or exact output swap
      * @returns The route
      */
-    static fromRoute(route, amount, tradeType) {
+    static fromRoute(route, amount, tradeType, percent = 100) {
         const amounts = new Array(route.tokenPath.length);
         let inputAmount;
         let outputAmount;
@@ -181,7 +182,7 @@ class Trade {
             outputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
         }
         return new Trade({
-            routes: [{ inputAmount, outputAmount, route }],
+            routes: [{ inputAmount, outputAmount, route, percent }],
             tradeType
         });
     }
@@ -197,7 +198,7 @@ class Trade {
      */
     static fromRoutes(routes, tradeType) {
         const populatedRoutes = [];
-        for (const { route, amount } of routes) {
+        for (const { route, amount, percent } of routes) {
             const amounts = new Array(route.tokenPath.length);
             let inputAmount;
             let outputAmount;
@@ -223,7 +224,7 @@ class Trade {
                 }
                 inputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
             }
-            populatedRoutes.push({ route, inputAmount, outputAmount });
+            populatedRoutes.push({ route, inputAmount, outputAmount, percent });
         }
         return new Trade({
             routes: populatedRoutes,
@@ -244,6 +245,7 @@ class Trade {
             ...constructorArguments,
             routes: [
                 {
+                    percent: constructorArguments.percent,
                     inputAmount: constructorArguments.inputAmount,
                     outputAmount: constructorArguments.outputAmount,
                     route: constructorArguments.route
@@ -329,11 +331,20 @@ class Trade {
         (0, tiny_invariant_1.default)(routes.length > 0, 'ROUTES');
         const bestTrades = [];
         for (const route of routes) {
-            const trade = Trade.fromRoute(route, currencyAmountIn, internalConstants_1.TradeType.EXACT_INPUT);
+            let trade;
+            try {
+                trade = Trade.fromRoute(route, currencyAmountIn, internalConstants_1.TradeType.EXACT_INPUT);
+            }
+            catch (error) {
+                // not enough liquidity in this pair
+                if (error.isInsufficientInputAmountError) {
+                    continue;
+                }
+                throw error;
+            }
             // FIXME! Sorting bug multiple pools
-            if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
+            if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0))
                 continue;
-            }
             (0, utils_1.sortedInsert)(bestTrades, trade, maxNumResults, tradeComparator);
         }
         return bestTrades;
@@ -342,13 +353,57 @@ class Trade {
         (0, tiny_invariant_1.default)(routes.length > 0, 'ROUTES');
         const bestTrades = [];
         for (const route of routes) {
-            const trade = Trade.fromRoute(route, currencyAmountOut, internalConstants_1.TradeType.EXACT_OUTPUT);
-            if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
-                continue;
+            let trade;
+            try {
+                trade = Trade.fromRoute(route, currencyAmountOut, internalConstants_1.TradeType.EXACT_OUTPUT);
             }
+            catch (error) {
+                // not enough liquidity in this pair
+                if (error.isInsufficientReservesError) {
+                    continue;
+                }
+                throw error;
+            }
+            if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0))
+                continue;
             (0, utils_1.sortedInsert)(bestTrades, trade, maxNumResults, tradeComparator);
         }
         return bestTrades;
     }
+    static bestTradeWithSplit(routes, amount, percents, tradeType, swapConfig = { minSplits: 1, maxSplits: 10 }) {
+        (0, tiny_invariant_1.default)(routes.length > 0, 'ROUTES');
+        (0, tiny_invariant_1.default)(percents.length > 0, 'PERCENTS');
+        // Compute routes for all percents for all routes
+        const percentToTrades = {};
+        for (const percent of percents) {
+            const splitAmount = amount.multiply(percent).divide(100);
+            for (const route of routes) {
+                let trade;
+                try {
+                    trade = Trade.fromRoute(route, splitAmount, tradeType, percent);
+                }
+                catch (error) {
+                    // not enough liquidity in this pair
+                    if (error.isInsufficientReservesError || error.isInsufficientInputAmountError) {
+                        continue;
+                    }
+                    throw error;
+                }
+                if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0))
+                    continue;
+                if (!percentToTrades[percent]) {
+                    percentToTrades[percent] = [];
+                }
+                percentToTrades[percent].push(trade);
+            }
+        }
+        const bestTrades = (0, getBestSwapRoute_1.getBestSwapRoute)(tradeType, percentToTrades, percents, swapConfig);
+        if (!bestTrades)
+            return null;
+        return new Trade({
+            routes: bestTrades.map(({ inputAmount, outputAmount, route, swaps }) => ({ inputAmount, outputAmount, route, percent: swaps[0].percent })),
+            tradeType
+        });
+    }
 }
 exports.Trade = Trade;

package/build/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+export declare class InsufficientReservesError extends Error {
+    readonly isInsufficientReservesError = true;
+    constructor();
+}
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+export declare class InsufficientInputAmountError extends Error {
+    readonly isInsufficientInputAmountError = true;
+    constructor();
+}

package/build/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientInputAmountError = exports.InsufficientReservesError = void 0;
+// see https://stackoverflow.com/a/41102306
+const CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object;
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+class InsufficientReservesError extends Error {
+    constructor() {
+        super();
+        this.isInsufficientReservesError = true;
+        this.name = this.constructor.name;
+        if (CAN_SET_PROTOTYPE)
+            Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.InsufficientReservesError = InsufficientReservesError;
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+class InsufficientInputAmountError extends Error {
+    constructor() {
+        super();
+        this.isInsufficientInputAmountError = true;
+        this.name = this.constructor.name;
+        if (CAN_SET_PROTOTYPE)
+            Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.InsufficientInputAmountError = InsufficientInputAmountError;

package/build/utils/common.d.ts

@@ -1,11 +1,12 @@
 export declare function parseTrade(trade: any): {
+    route: never[];
+    memo: string;
+    swaps: any;
     input: any;
     output: any;
     minReceived: any;
     maxSent: any;
     priceImpact: any;
-    memo: string;
-    route: any;
     executionPrice: {
         numerator: any;
         denominator: any;

package/build/utils/common.js

@@ -7,24 +7,37 @@ function parseTrade(trade) {
     // Parse Trade into api format object
     const slippage = new entities_1.Percent(3, 100); // 0.3%
     const receiver = '<receiver>';
-    const tradeType = trade.tradeType == internalConstants_1.TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout';
-    const route = trade.route.pools.map(p => p.id);
-    const maxSent = trade.inputAmount;
-    const minReceived = trade.minimumAmountOut(slippage);
-    const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`;
+    const exactIn = trade.tradeType === internalConstants_1.TradeType.EXACT_INPUT;
+    console.log('trade.tradeType', trade.tradeType, internalConstants_1.TradeType.EXACT_INPUT);
+    const maxSent = exactIn ? trade.inputAmount : trade.maximumAmountIn(slippage);
+    const minReceived = exactIn ? trade.minimumAmountOut(slippage) : trade.outputAmount;
+    const tradeType = exactIn ? 'swapexactin' : 'swapexactout';
+    const swaps = trade.swaps.map(({ route, percent, inputAmount, outputAmount }) => {
+        route = route.pools.map(p => p.id);
+        const maxSent = exactIn ? inputAmount : trade.maximumAmountIn(slippage, inputAmount);
+        const minReceived = exactIn ? trade.minimumAmountOut(slippage, outputAmount) : outputAmount;
+        const input = inputAmount.toAsset();
+        const output = outputAmount.toAsset();
+        const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`;
+        return { input, route, output, percent, memo, maxSent: maxSent.toFixed(), minReceived: minReceived.toFixed() };
+    });
     const result = {
+        route: [],
+        memo: '',
+        swaps,
         input: trade.inputAmount.toFixed(),
         output: trade.outputAmount.toFixed(),
         minReceived: minReceived.toFixed(),
         maxSent: maxSent.toFixed(),
         priceImpact: trade.priceImpact.toSignificant(2),
-        memo,
-        route,
         executionPrice: {
             numerator: trade.executionPrice.numerator.toString(),
             denominator: trade.executionPrice.denominator.toString()
         }
     };
+    // FIXME DEPRECATED Hotfix for legacy v1
+    result.route = trade.swaps[0].route.pools.map((p) => p.id);
+    result.memo = `${tradeType}#${result.route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`;
     return result;
 }
 exports.parseTrade = parseTrade;

package/build/utils/getBestSwapRoute.d.ts

@@ -0,0 +1,9 @@
+import { Currency } from '../entities/currency';
+import { Trade } from '../entities/trade';
+import { TradeType } from '../internalConstants';
+export declare function getBestSwapRoute(routeType: TradeType, percentToQuotes: {
+    [percent: number]: Trade<Currency, Currency, TradeType>[];
+}, percents: number[], swapRouteConfig?: {
+    minSplits: number;
+    maxSplits: number;
+}): Trade<Currency, Currency, TradeType>[] | null;

package/build/utils/getBestSwapRoute.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestSwapRoute = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const queue_1 = __importDefault(require("mnemonist/queue"));
+const fixed_reverse_heap_1 = __importDefault(require("mnemonist/fixed-reverse-heap"));
+const internalConstants_1 = require("../internalConstants");
+function getBestSwapRoute(routeType, percentToQuotes, percents, swapRouteConfig = { minSplits: 1, maxSplits: 8 }) {
+    const percentToSortedQuotes = lodash_1.default.mapValues(percentToQuotes, (routeQuotes) => {
+        return routeQuotes.sort((routeQuoteA, routeQuoteB) => {
+            if (routeType == internalConstants_1.TradeType.EXACT_INPUT) {
+                return routeQuoteA.outputAmount.greaterThan(routeQuoteB.outputAmount) ? -1 : 1;
+            }
+            else {
+                return routeQuoteA.inputAmount.lessThan(routeQuoteB.inputAmount) ? -1 : 1;
+            }
+        });
+    });
+    const quoteCompFn = routeType == internalConstants_1.TradeType.EXACT_INPUT
+        ? (a, b) => a.greaterThan(b)
+        : (a, b) => a.lessThan(b);
+    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;
+    const bestSwapsPerSplit = new fixed_reverse_heap_1.default(Array, (a, b) => {
+        return quoteCompFn(a.quote, b.quote) ? -1 : 1;
+    }, 3);
+    const { minSplits, maxSplits } = swapRouteConfig;
+    if (!percentToSortedQuotes[100] || minSplits > 1) {
+        console.log({
+            percentToSortedQuotes: lodash_1.default.mapValues(percentToSortedQuotes, (p) => p.length),
+        }, 'Did not find a valid route without any splits. Continuing search anyway.');
+    }
+    else {
+        bestQuote = percentToSortedQuotes[100][0].outputAmount;
+        bestSwap = [percentToSortedQuotes[100][0]];
+        for (const routeWithQuote of percentToSortedQuotes[100].slice(0, 5)) {
+            bestSwapsPerSplit.push({
+                quote: routeWithQuote.outputAmount,
+                routes: [routeWithQuote],
+            });
+        }
+    }
+    const queue = new queue_1.default();
+    if (percents.length === 0)
+        return null; // Handle empty percents array
+    for (let i = percents.length - 1; i >= 0; i--) {
+        const percent = percents[i];
+        if (!percentToSortedQuotes[percent]) {
+            console.log('continue', { percent });
+            continue;
+        }
+        queue.enqueue({
+            curRoutes: [percentToSortedQuotes[percent][0]],
+            percentIndex: i,
+            remainingPercent: 100 - percent,
+            special: false,
+        });
+        if (!percentToSortedQuotes[percent] ||
+            !percentToSortedQuotes[percent][1]) {
+            console.log('continue2', { percent });
+            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;
+        splits++;
+        if (splits >= 3 && bestSwap && bestSwap.length < splits - 1) {
+            break;
+        }
+        if (splits > maxSplits) {
+            break;
+        }
+        while (layer > 0) {
+            layer--;
+            const { remainingPercent, curRoutes, percentIndex, special } = queue.dequeue();
+            for (let i = percentIndex; i >= 0; i--) {
+                const percentA = percents[i];
+                if (percentA > remainingPercent) {
+                    continue;
+                }
+                if (!percentToSortedQuotes[percentA]) {
+                    continue;
+                }
+                const candidateRoutesA = percentToSortedQuotes[percentA];
+                const routeWithQuoteA = findFirstRouteNotUsingUsedPools(curRoutes, candidateRoutesA);
+                if (!routeWithQuoteA) {
+                    continue;
+                }
+                const remainingPercentNew = remainingPercent - percentA;
+                const curRoutesNew = [...curRoutes, routeWithQuoteA];
+                if (remainingPercentNew == 0 && splits >= minSplits) {
+                    const quotesNew = lodash_1.default.map(curRoutesNew, (r) => r.outputAmount);
+                    const quoteNew = sumFn(quotesNew);
+                    bestSwapsPerSplit.push({
+                        quote: quoteNew,
+                        routes: curRoutesNew,
+                    });
+                    if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
+                        bestQuote = quoteNew;
+                        bestSwap = curRoutesNew;
+                    }
+                }
+                else {
+                    queue.enqueue({
+                        curRoutes: curRoutesNew,
+                        remainingPercent: remainingPercentNew,
+                        percentIndex: i,
+                        special,
+                    });
+                }
+            }
+        }
+    }
+    if (!bestSwap) {
+        console.log(`Could not find a valid swap`);
+        return null;
+    }
+    const quote = sumFn(lodash_1.default.map(bestSwap, (routeWithValidQuote) => routeWithValidQuote.outputAmount));
+    const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) => routeAmountB.outputAmount.greaterThan(routeAmountA.outputAmount) ? 1 : -1);
+    return routeWithQuotes;
+}
+exports.getBestSwapRoute = getBestSwapRoute;
+const findFirstRouteNotUsingUsedPools = (usedRoutes, candidateRoutes) => {
+    const usedPools = new Set();
+    usedRoutes.forEach(r => r.route.pools.forEach(pool => usedPools.add(pool.id)));
+    for (const candidate of candidateRoutes) {
+        if (candidate.route.pools.every(pool => !usedPools.has(pool.id))) {
+            return candidate;
+        }
+    }
+    return null;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "",
   "main": "build/index.js",
   "scripts": {
@@ -45,7 +45,7 @@
     "redis": "^4.6.10",
     "rimraf": "^4.1.1",
     "ts-jest": "^28.0.4",
-    "ts-node": "^10.9.1",
+    "ts-node": "^10.9.2",
     "typescript": "^4.9.4"
   },
   "dependencies": {
@@ -55,6 +55,8 @@
     "eosjs": "^22.1.0",
     "eosjs-account-name": "2.3.0",
     "jsbi": "^4.3.0",
+    "lodash": "^4.17.21",
+    "mnemonist": "^0.39.8",
     "msgpack-lite": "^0.1.26",
     "node-fetch": "2",
     "tiny-invariant": "^1.1.0",

package/src/entities/pool.ts

@@ -13,6 +13,7 @@ import { TickMath } from "../utils/tickMath";
 import { Tick, TickConstructorArgs } from "./tick";
 import { NoTickDataProvider, TickDataProvider } from "./tickDataProvider";
 import { TickListDataProvider } from "./tickListDataProvider";
+import {InsufficientReservesError, InsufficientInputAmountError} from "../errors";
 
 export interface PoolConstructorArgs {
   id: number,
@@ -190,10 +191,17 @@ export class Pool {
 
     const zeroForOne = inputAmount.currency.equals(this.tokenA);
 
-    const {
-      amountCalculated: outputAmount,
-    } = this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
+    const { amountA, amountB } = this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
+
     const outputToken = zeroForOne ? this.tokenB : this.tokenA;
+    const outputAmount = zeroForOne ? amountB : amountA;
+    const amountIn = zeroForOne ? amountA : amountB;
+
+    //console.log(JSBI.equal(amountIn, inputAmount.quotient))
+    if (!JSBI.equal(amountIn, inputAmount.quotient)) {
+      throw new InsufficientInputAmountError
+    }
+
     return CurrencyAmount.fromRawAmount(
         outputToken,
         JSBI.multiply(outputAmount, NEGATIVE_ONE)
@@ -212,14 +220,16 @@ export class Pool {
   ): CurrencyAmount<Token> {
     const zeroForOne = outputAmount.currency.equals(this.tokenB);
 
-    const {
-      amountCalculated: inputAmount,
-    } = this.swap(
-      zeroForOne,
-      JSBI.multiply(outputAmount.quotient, NEGATIVE_ONE),
-      sqrtPriceLimitX64
-    );
+    const { amountA, amountB } = this.swap(zeroForOne, JSBI.multiply(outputAmount.quotient, NEGATIVE_ONE), sqrtPriceLimitX64);
+
     const inputToken = zeroForOne ? this.tokenA : this.tokenB;
+    const inputAmount = zeroForOne ? amountA : amountB;
+    const amountOutReceived = JSBI.multiply(zeroForOne ? amountB : amountA, NEGATIVE_ONE)
+
+    if (!JSBI.equal(amountOutReceived, outputAmount.quotient)) {
+      throw new InsufficientReservesError
+    }
+
     return CurrencyAmount.fromRawAmount(inputToken, inputAmount)
   }
 
@@ -238,7 +248,8 @@ export class Pool {
     amountSpecified: JSBI,
     sqrtPriceLimitX64?: JSBI
   ): {
-    amountCalculated: JSBI;
+    amountA: JSBI;
+    amountB: JSBI;
     sqrtPriceX64: JSBI;
     liquidity: JSBI;
     tickCurrent: number;
@@ -270,8 +281,6 @@ export class Pool {
 
     const exactInput = JSBI.greaterThanOrEqual(amountSpecified, ZERO);
 
-    // keep track of swap state
-
     const state = {
       amountSpecifiedRemaining: amountSpecified,
       amountCalculated: ZERO,
@@ -280,7 +289,6 @@ export class Pool {
       liquidity: this.liquidity,
     };
 
-    // start swap while loop
     while (
       JSBI.notEqual(state.amountSpecifiedRemaining, ZERO) &&
       state.sqrtPriceX64 != sqrtPriceLimitX64
@@ -288,9 +296,6 @@ export class Pool {
       const step: Partial<StepComputations> = {};
       step.sqrtPriceStartX64 = state.sqrtPriceX64;
 
-      // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
-      // by simply traversing to the next available tick, we instead need to exactly replicate
-      // tickBitmap.nextInitializedTickWithinOneWord
       [step.tickNext, step.initialized] =
         this.tickDataProvider.nextInitializedTickWithinOneWord(
           state.tick,
@@ -340,15 +345,11 @@ export class Pool {
         );
       }
 
-      // TODO
       if (JSBI.equal(state.sqrtPriceX64, step.sqrtPriceNextX64)) {
-        // if the tick is initialized, run the tick transition
         if (step.initialized) {
           let liquidityNet = JSBI.BigInt(
             (this.tickDataProvider.getTick(step.tickNext)).liquidityNet
           );
-          // if we're moving leftward, we interpret liquidityNet as the opposite sign
-          // safe because liquidityNet cannot be type(int128).min
           if (zeroForOne)
             liquidityNet = JSBI.multiply(liquidityNet, NEGATIVE_ONE);
 
@@ -360,14 +361,20 @@ export class Pool {
 
         state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
       } else if (JSBI.notEqual(state.sqrtPriceX64, step.sqrtPriceStartX64)) {
-        // updated comparison function
-        // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
         state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
       }
     }
 
+    const amountA = zeroForOne == exactInput 
+      ? JSBI.subtract(amountSpecified, state.amountSpecifiedRemaining)
+      : state.amountCalculated;
+    const amountB = zeroForOne == exactInput 
+      ? state.amountCalculated
+      : JSBI.subtract(amountSpecified, state.amountSpecifiedRemaining);
+
     return {
-      amountCalculated: state.amountCalculated,
+      amountA,
+      amountB,
       sqrtPriceX64: state.sqrtPriceX64,
       liquidity: state.liquidity,
       tickCurrent: state.tick,

package/src/entities/trade.ts

@@ -1,12 +1,13 @@
 import invariant from 'tiny-invariant'
 
+
 import { Currency } from './currency'
 import { Fraction, Percent, Price, CurrencyAmount } from './fractions'
-import { sortedInsert, parseTrade } from '../utils'
+import { sortedInsert } from '../utils'
 import { Token } from './token'
 import { ONE, ZERO, TradeType } from '../internalConstants'
-import { Pool } from './pool'
 import { Route } from './route'
+import { getBestSwapRoute } from '../utils/getBestSwapRoute'
 
 /**
  * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
@@ -84,6 +85,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
    * make up the trade.
    */
   public readonly swaps: {
+    percent: number,
     route: Route<TInput, TOutput>
     inputAmount: CurrencyAmount<TInput>
     outputAmount: CurrencyAmount<TOutput>
@@ -230,7 +232,8 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
   public static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(
     route: Route<TInput, TOutput>,
     amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>,
-    tradeType: TTradeType
+    tradeType: TTradeType,
+    percent = 100
   ): Trade<TInput, TOutput, TTradeType> {
     const amounts: CurrencyAmount<Token>[] = new Array(route.tokenPath.length)
     let inputAmount: CurrencyAmount<TInput>
@@ -262,7 +265,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     }
 
     return new Trade({
-      routes: [{ inputAmount, outputAmount, route }],
+      routes: [{ inputAmount, outputAmount, route, percent }],
       tradeType
     })
   }
@@ -280,17 +283,19 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
   public static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(
     routes: {
       amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>
-      route: Route<TInput, TOutput>
+      route: Route<TInput, TOutput>,
+      percent: number
     }[],
     tradeType: TTradeType
   ): Trade<TInput, TOutput, TTradeType> {
     const populatedRoutes: {
+      percent: number,
       route: Route<TInput, TOutput>
       inputAmount: CurrencyAmount<TInput>
       outputAmount: CurrencyAmount<TOutput>
     }[] = []
 
-    for (const { route, amount } of routes) {
+    for (const { route, amount, percent } of routes) {
       const amounts: CurrencyAmount<Token>[] = new Array(route.tokenPath.length)
       let inputAmount: CurrencyAmount<TInput>
       let outputAmount: CurrencyAmount<TOutput>
@@ -329,7 +334,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
         inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator)
       }
 
-      populatedRoutes.push({ route, inputAmount, outputAmount })
+      populatedRoutes.push({ route, inputAmount, outputAmount, percent })
     }
 
     return new Trade({
@@ -352,6 +357,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     TOutput extends Currency,
     TTradeType extends TradeType
   >(constructorArguments: {
+    percent: number,
     route: Route<TInput, TOutput>
     inputAmount: CurrencyAmount<TInput>
     outputAmount: CurrencyAmount<TOutput>
@@ -361,6 +367,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
       ...constructorArguments,
       routes: [
         {
+          percent: constructorArguments.percent,
           inputAmount: constructorArguments.inputAmount,
           outputAmount: constructorArguments.outputAmount,
           route: constructorArguments.route
@@ -384,6 +391,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     TTradeType extends TradeType
   >(constructorArguments: {
     routes: {
+      percent: number
       route: Route<TInput, TOutput>
       inputAmount: CurrencyAmount<TInput>
       outputAmount: CurrencyAmount<TOutput>
@@ -403,6 +411,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     tradeType
   }: {
     routes: {
+      percent: number,
       route: Route<TInput, TOutput>
       inputAmount: CurrencyAmount<TInput>
       outputAmount: CurrencyAmount<TOutput>
@@ -490,12 +499,20 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
     const bestTrades: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] = []
     for (const route of routes) {
-      const trade = Trade.fromRoute(route, currencyAmountIn, TradeType.EXACT_INPUT)
+      let trade
+
+      try {
+        trade = Trade.fromRoute(route, currencyAmountIn, TradeType.EXACT_INPUT)
+      } catch (error) {
+        // not enough liquidity in this pair
+        if ((error as any).isInsufficientInputAmountError) {
+          continue
+        }
+        throw error
+      }
 
       // FIXME! Sorting bug multiple pools
-      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
-        continue
-      }
+      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue
 
       sortedInsert(
         bestTrades,
@@ -517,12 +534,19 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
     const bestTrades: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] = []
     for (const route of routes) {
-      const trade = Trade.fromRoute(route, currencyAmountOut, TradeType.EXACT_OUTPUT)
-
-      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
-        continue
+      let trade 
+      try {
+        trade = Trade.fromRoute(route, currencyAmountOut, TradeType.EXACT_OUTPUT)
+      } catch (error) {
+        // not enough liquidity in this pair
+        if ((error as any).isInsufficientReservesError) {
+          continue
+        }
+        throw error
       }
 
+      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue
+
       sortedInsert(
         bestTrades,
         trade,
@@ -533,4 +557,50 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
     return bestTrades
   }
+
+  public static bestTradeWithSplit<TInput extends Currency, TOutput extends Currency>(
+    routes: Route<TInput, TOutput>[],
+    amount: CurrencyAmount<Currency>,
+    percents: number[],
+    tradeType: TradeType,
+    swapConfig = { minSplits: 1, maxSplits: 10 }
+  ): Trade<Currency, Currency, TradeType> | null {
+    invariant(routes.length > 0, 'ROUTES')
+    invariant(percents.length > 0, 'PERCENTS')
+
+    // Compute routes for all percents for all routes
+    const percentToTrades: { [percent: number]: Trade<Currency, Currency, TradeType>[] } = {};
+    for (const percent of percents) {
+      const splitAmount = amount.multiply(percent).divide(100)
+
+      for (const route of routes) {
+        let trade 
+        try {
+          trade = Trade.fromRoute(route, splitAmount, tradeType, percent)
+        } catch (error) {
+          // not enough liquidity in this pair
+          if ((error as any).isInsufficientReservesError || (error as any).isInsufficientInputAmountError) {
+            continue
+          }
+          throw error
+        }
+
+        if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue
+
+        if (!percentToTrades[percent]) {
+          percentToTrades[percent] = []
+        }
+
+        percentToTrades[percent].push(trade)
+      }
+    }
+    const bestTrades = getBestSwapRoute(tradeType, percentToTrades, percents, swapConfig)
+    if (!bestTrades) return null
+
+    return new Trade({
+      routes: bestTrades.map(({ inputAmount, outputAmount, route, swaps }) =>
+        ({ inputAmount, outputAmount, route, percent: swaps[0].percent })),
+      tradeType }
+    )
+  }
 }

package/src/errors.ts

@@ -0,0 +1,30 @@
+// see https://stackoverflow.com/a/41102306
+const CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object
+
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+export class InsufficientReservesError extends Error {
+  public readonly isInsufficientReservesError = true
+
+  public constructor() {
+    super()
+    this.name = this.constructor.name
+    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+export class InsufficientInputAmountError extends Error {
+  public readonly isInsufficientInputAmountError = true
+
+  public constructor() {
+    super()
+    this.name = this.constructor.name
+    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)
+  }
+}

package/src/utils/common.ts

@@ -1,4 +1,4 @@
-import { Percent } from "../entities"
+import { Percent, Trade } from "../entities"
 import { TradeType } from "../internalConstants"
 
 export function parseTrade(trade) {
@@ -6,27 +6,46 @@ export function parseTrade(trade) {
   const slippage = new Percent(3, 100) // 0.3%
   const receiver = '<receiver>'
 
-  const tradeType = trade.tradeType == TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout'
+  const exactIn = trade.tradeType === TradeType.EXACT_INPUT
+  console.log('trade.tradeType', trade.tradeType, TradeType.EXACT_INPUT)
 
-  const route = trade.route.pools.map(p => p.id)
-  const maxSent = trade.inputAmount
-  const minReceived = trade.minimumAmountOut(slippage)
-  const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`
+  const maxSent = exactIn ? trade.inputAmount : trade.maximumAmountIn(slippage)
+  const minReceived = exactIn ? trade.minimumAmountOut(slippage) : trade.outputAmount
+
+  const tradeType = exactIn ? 'swapexactin' : 'swapexactout'
+
+  const swaps = trade.swaps.map(({ route, percent, inputAmount, outputAmount }) => {
+    route = route.pools.map(p => p.id)
+
+    const maxSent = exactIn ? inputAmount : trade.maximumAmountIn(slippage, inputAmount)
+    const minReceived = exactIn ? trade.minimumAmountOut(slippage, outputAmount) : outputAmount
+
+    const input = inputAmount.toAsset()
+    const output = outputAmount.toAsset()
+
+    const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`
+    return { input, route, output, percent, memo, maxSent: maxSent.toFixed(), minReceived: minReceived.toFixed() }
+  })
 
   const result = {
+    route: [],
+    memo: '',
+    swaps,
     input: trade.inputAmount.toFixed(),
     output: trade.outputAmount.toFixed(),
     minReceived: minReceived.toFixed(),
     maxSent: maxSent.toFixed(),
     priceImpact: trade.priceImpact.toSignificant(2),
-    memo,
-    route,
+
     executionPrice: {
       numerator: trade.executionPrice.numerator.toString(),
       denominator: trade.executionPrice.denominator.toString()
     }
   }
 
+  // FIXME DEPRECATED Hotfix for legacy v1
+  result!.route = trade.swaps[0].route.pools.map((p) => p.id)
+  result!.memo = `${tradeType}#${result.route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`
+
   return result
 }
-

package/src/utils/getBestSwapRoute.ts

@@ -0,0 +1,223 @@
+import _ from 'lodash'
+import Queue from 'mnemonist/queue'
+import FixedReverseHeap from 'mnemonist/fixed-reverse-heap'
+
+import { Currency } from '../entities/currency'
+import { Trade } from '../entities/trade'
+import { CurrencyAmount } from '../entities/fractions'
+import { TradeType } from '../internalConstants'
+
+export function getBestSwapRoute(
+  routeType: TradeType,
+  percentToQuotes: { [percent: number]: Trade<Currency, Currency, TradeType>[] },
+  percents: number[],
+  swapRouteConfig = { minSplits: 1, maxSplits: 8 }
+): Trade<Currency, Currency, TradeType>[] | null {
+  const percentToSortedQuotes = _.mapValues(
+    percentToQuotes,
+    (routeQuotes: Trade<Currency, Currency, TradeType>[]) => {
+      return routeQuotes.sort((routeQuoteA, routeQuoteB) => {
+        if (routeType == TradeType.EXACT_INPUT) {
+          return routeQuoteA.outputAmount.greaterThan(routeQuoteB.outputAmount) ? -1 : 1;
+        } else {
+          return routeQuoteA.inputAmount.lessThan(routeQuoteB.inputAmount) ? -1 : 1;
+        }
+      });
+    }
+  );
+
+  const quoteCompFn =
+    routeType == TradeType.EXACT_INPUT
+      ? (a: CurrencyAmount<Currency>, b: CurrencyAmount<Currency>) => a.greaterThan(b)
+      : (a: CurrencyAmount<Currency>, b: CurrencyAmount<Currency>) => a.lessThan(b);
+
+  const sumFn = (currencyAmounts: CurrencyAmount<Currency>[]): CurrencyAmount<Currency> => {
+    let sum = currencyAmounts[0]!;
+    for (let i = 1; i < currencyAmounts.length; i++) {
+      sum = sum.add(currencyAmounts[i]!);
+    }
+    return sum;
+  };
+
+  let bestQuote: CurrencyAmount<Currency> | undefined;
+  let bestSwap: Trade<Currency, Currency, TradeType>[] | undefined;
+
+  const bestSwapsPerSplit = new FixedReverseHeap<{
+    quote: CurrencyAmount<Currency>;
+    routes: Trade<Currency, Currency, TradeType>[];
+  }>(
+    Array,
+    (a, b) => {
+      return quoteCompFn(a.quote, b.quote) ? -1 : 1;
+    },
+    3
+  );
+
+  const { minSplits, maxSplits } = swapRouteConfig;
+
+  if (!percentToSortedQuotes[100] || minSplits > 1) {
+    console.log(
+      {
+        percentToSortedQuotes: _.mapValues(
+          percentToSortedQuotes,
+          (p) => p.length
+        ),
+      },
+      'Did not find a valid route without any splits. Continuing search anyway.'
+    );
+  } else {
+    bestQuote = percentToSortedQuotes[100][0]!.outputAmount;
+    bestSwap = [percentToSortedQuotes[100][0]!];
+
+    for (const routeWithQuote of percentToSortedQuotes[100].slice(0, 5)) {
+      bestSwapsPerSplit.push({
+        quote: routeWithQuote.outputAmount,
+        routes: [routeWithQuote],
+      });
+    }
+  }
+
+  const queue = new Queue<{
+    percentIndex: number;
+    curRoutes: Trade<Currency, Currency, TradeType>[];
+    remainingPercent: number;
+    special: boolean;
+  }>();
+
+  if (percents.length === 0) return null; // Handle empty percents array
+
+  for (let i = percents.length - 1; i >= 0; i--) {
+    const percent = percents[i];
+
+    if (!percentToSortedQuotes[percent]) {
+      console.log('continue', { percent });
+      continue;
+    }
+
+    queue.enqueue({
+      curRoutes: [percentToSortedQuotes[percent]![0]!],
+      percentIndex: i,
+      remainingPercent: 100 - percent,
+      special: false,
+    });
+
+    if (
+      !percentToSortedQuotes[percent] ||
+      !percentToSortedQuotes[percent]![1]
+    ) {
+      console.log('continue2', { percent });
+      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;
+    splits++;
+
+    if (splits >= 3 && bestSwap && bestSwap.length < splits - 1) {
+      break;
+    }
+
+    if (splits > maxSplits) {
+      break;
+    }
+
+    while (layer > 0) {
+      layer--;
+
+      const { remainingPercent, curRoutes, percentIndex, special } =
+        queue.dequeue()!;
+
+      for (let i = percentIndex; i >= 0; i--) {
+        const percentA = percents[i]!;
+
+        if (percentA > remainingPercent) {
+          continue;
+        }
+
+        if (!percentToSortedQuotes[percentA]) {
+          continue;
+        }
+
+        const candidateRoutesA = percentToSortedQuotes[percentA]!;
+
+        const routeWithQuoteA = findFirstRouteNotUsingUsedPools(
+          curRoutes,
+          candidateRoutesA,
+        );
+
+        if (!routeWithQuoteA) {
+          continue;
+        }
+
+        const remainingPercentNew = remainingPercent - percentA;
+        const curRoutesNew = [...curRoutes, routeWithQuoteA];
+
+        if (remainingPercentNew == 0 && splits >= minSplits) {
+          const quotesNew = _.map(curRoutesNew, (r) => r.outputAmount);
+          const quoteNew = sumFn(quotesNew);
+
+          bestSwapsPerSplit.push({
+            quote: quoteNew,
+            routes: curRoutesNew,
+          });
+
+          if (!bestQuote || quoteCompFn(quoteNew, bestQuote)) {
+            bestQuote = quoteNew;
+            bestSwap = curRoutesNew;
+          }
+        } else {
+          queue.enqueue({
+            curRoutes: curRoutesNew,
+            remainingPercent: remainingPercentNew,
+            percentIndex: i,
+            special,
+          });
+        }
+      }
+    }
+  }
+
+  if (!bestSwap) {
+    console.log(`Could not find a valid swap`);
+    return null;
+  }
+
+  const quote = sumFn(
+    _.map(bestSwap, (routeWithValidQuote) => routeWithValidQuote.outputAmount)
+  );
+
+  const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) =>
+    routeAmountB.outputAmount.greaterThan(routeAmountA.outputAmount) ? 1 : -1
+  );
+
+  return routeWithQuotes;
+}
+
+
+const findFirstRouteNotUsingUsedPools = (
+  usedRoutes: Trade<Currency, Currency, TradeType>[],
+  candidateRoutes: Trade<Currency, Currency, TradeType>[],
+): Trade<Currency, Currency, TradeType> | null => {
+  const usedPools = new Set<number>();
+  usedRoutes.forEach(r => r.route.pools.forEach(pool => usedPools.add(pool.id)));
+
+  for (const candidate of candidateRoutes) {
+    if (candidate.route.pools.every(pool => !usedPools.has(pool.id))) {
+      return candidate;
+    }
+  }
+
+  return null;
+}