@alcorexchange/alcor-swap-sdk 1.0.32 → 1.0.34

package/build/entities/pool.d.ts

@@ -7,6 +7,7 @@ import { Tick, TickConstructorArgs } from "./tick";
 import { TickDataProvider } from "./tickDataProvider";
 export interface PoolConstructorArgs {
     id: number;
+    active: boolean;
     tokenA: Token;
     tokenB: Token;
     fee: FeeAmount;
@@ -22,6 +23,7 @@ export interface PoolConstructorArgs {
  */
 export declare class Pool {
     readonly id: number;
+    readonly active: boolean;
     readonly tokenA: Token;
     readonly tokenB: Token;
     readonly fee: FeeAmount;
@@ -48,7 +50,7 @@ export declare class Pool {
      * @param tickCurrent The current tick of the pool
      * @param ticks The current state of the pool ticks or a data provider that can return tick data
      */
-    constructor({ id, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks, feeGrowthGlobalAX64, feeGrowthGlobalBX64, }: PoolConstructorArgs);
+    constructor({ id, active, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks, feeGrowthGlobalAX64, feeGrowthGlobalBX64, }: PoolConstructorArgs);
     /**
      * Returns true if the token is either tokenA or tokenB
      * @param token The token to check

package/build/entities/pool.js

@@ -35,7 +35,7 @@ class Pool {
      * @param tickCurrent The current tick of the pool
      * @param ticks The current state of the pool ticks or a data provider that can return tick data
      */
-    constructor({ id, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT, feeGrowthGlobalAX64 = 0, feeGrowthGlobalBX64 = 0, }) {
+    constructor({ id, active, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT, feeGrowthGlobalAX64 = 0, feeGrowthGlobalBX64 = 0, }) {
         (0, tiny_invariant_1.default)(Number.isInteger(fee) && fee < 1000000, "FEE");
         const tickCurrentSqrtRatioX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickCurrent);
         const nextTickSqrtRatioX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickCurrent + 1);
@@ -44,6 +44,7 @@ class Pool {
         // always create a copy of the list since we want the pool's tick list to be immutable
         this.id = id;
         this.fee = fee;
+        this.active = active;
         this.sqrtPriceX64 = jsbi_1.default.BigInt(sqrtPriceX64);
         this.liquidity = jsbi_1.default.BigInt(liquidity);
         this.tickCurrent = tickCurrent;
@@ -211,6 +212,7 @@ class Pool {
             id: pool.id,
             tokenA: token_1.Token.toJSON(pool.tokenA),
             tokenB: token_1.Token.toJSON(pool.tokenB),
+            active: pool.active,
             fee: pool.fee,
             sqrtPriceX64: pool.sqrtPriceX64.toString(),
             liquidity: pool.liquidity.toString(),
@@ -224,6 +226,7 @@ class Pool {
     static fromJSON(json) {
         return new Pool({
             id: json.id,
+            active: json.active,
             tokenA: token_1.Token.fromJSON(json.tokenA),
             tokenB: token_1.Token.fromJSON(json.tokenB),
             fee: json.fee,

package/build/entities/position.js

@@ -126,6 +126,7 @@ class Position {
         // construct counterfactual pools
         const poolLower = new pool_1.Pool({
             id: this.pool.id,
+            active: this.pool.active,
             tokenA: this.pool.tokenA,
             tokenB: this.pool.tokenB,
             fee: this.pool.fee,
@@ -138,6 +139,7 @@ class Position {
         });
         const poolUpper = new pool_1.Pool({
             id: this.pool.id,
+            active: this.pool.active,
             tokenA: this.pool.tokenA,
             tokenB: this.pool.tokenB,
             fee: this.pool.fee,
@@ -203,6 +205,7 @@ class Position {
         // construct counterfactual pools
         const poolLower = new pool_1.Pool({
             id: this.pool.id,
+            active: this.pool.active,
             tokenA: this.pool.tokenA,
             tokenB: this.pool.tokenB,
             fee: this.pool.fee,
@@ -215,6 +218,7 @@ class Position {
         });
         const poolUpper = new pool_1.Pool({
             id: this.pool.id,
+            active: this.pool.active,
             tokenA: this.pool.tokenA,
             tokenB: this.pool.tokenB,
             fee: this.pool.fee,

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.EXACT_INPUT> | 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
@@ -331,9 +333,8 @@ class Trade {
         for (const route of routes) {
             const trade = Trade.fromRoute(route, currencyAmountIn, internalConstants_1.TradeType.EXACT_INPUT);
             // 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;
@@ -343,12 +344,36 @@ class Trade {
         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)) {
+            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) {
+                const trade = Trade.fromRoute(route, splitAmount, tradeType, percent);
+                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: internalConstants_1.TradeType.EXACT_INPUT
+        });
+    }
 }
 exports.Trade = Trade;

package/build/utils/common.d.ts

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

package/build/utils/common.js

@@ -7,19 +7,28 @@ 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 tradeType = trade.tradeType == internalConstants_1.TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout';
+    const swaps = trade.swaps.map(({ route, percent, inputAmount, outputAmount }) => {
+        route = route.pools.map(p => p.id);
+        let minReceived = outputAmount;
+        if (trade.tradeType === internalConstants_1.TradeType.EXACT_INPUT) {
+            minReceived = outputAmount.multiply(new entities_1.Percent(1).subtract(slippage));
+        }
+        const input = inputAmount.toSignificant();
+        const output = outputAmount.toSignificant();
+        const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`;
+        return { input, output, percent, memo };
+    });
     const result = {
+        swaps,
         input: trade.inputAmount.toFixed(),
         output: trade.outputAmount.toFixed(),
         minReceived: minReceived.toFixed(),
         maxSent: maxSent.toFixed(),
         priceImpact: trade.priceImpact.toSignificant(2),
-        memo,
-        route,
+        executionPriceStr: trade.executionPrice.toFixed(),
         executionPrice: {
             numerator: trade.executionPrice.numerator.toString(),
             denominator: trade.executionPrice.denominator.toString()

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/examples/getPositionAmounts.ts

@@ -54,12 +54,12 @@ async function main() {
   })
 
   const pool = new Pool({
-    ...poolRow,
+    ...poolRow as any,
     tokenA: parseToken(tokenA),
     tokenB: parseToken(tokenB),
     sqrtPriceX64,
     tickCurrent: tick,
-    ticks: ticks.sort((a, b) => a.id - b.id)
+    ticks: ticks.sort((a: any, b: any) => a.id - b.id)
   })
 
   const { rows: positions } = await rpc.get_table_rows({

package/examples/getTrateRoute.ts

@@ -28,6 +28,7 @@ async function main() {
   const pools: Pool[] = []
 
   // We have to get all pools with fetched ticks for them
+  let i = 0
   for (const p of rows) {
     const { id, tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = p
 
@@ -40,13 +41,15 @@ async function main() {
     if (ticks.length == 0) continue
 
     pools.push(new Pool({
-      ...p,
+      ...p as any,
       tokenA: parseToken(tokenA),
       tokenB: parseToken(tokenB),
       sqrtPriceX64,
       tickCurrent: tick,
-      ticks: ticks.sort((a, b) => a.id - b.id)
+      ticks: ticks.sort((a: any, b: any) => a.id - b.id)
     }))
+    i += 1
+    process.stdout.write(`fetching ticks: ${i}/${rows.length} \r`)
   }
 
   // 1.0000 EOS
@@ -56,9 +59,8 @@ async function main() {
   const receiver = 'myaccount'
 
   // First trade sorted by biggest output
-  //const [trade] = Trade.bestTradeExactIn(pools, amountIn, tokenOut, { maxHops: 3 })
-  const routes = computeAllRoutes(amountIn.currency, tokenOut, pools, 3)
-  const [trade] = Trade.bestTradeExactIn(routes, pools, amountIn, 3)
+  const routes = computeAllRoutes(amountIn.currency, tokenOut, pools, 2)
+  const [trade] = Trade.bestTradeExactIn(routes, amountIn, 1)
 
   const route = trade.route.pools.map(p => p.id)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "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

@@ -16,6 +16,7 @@ import { TickListDataProvider } from "./tickListDataProvider";
 
 export interface PoolConstructorArgs {
   id: number,
+  active: boolean,
   tokenA: Token,
   tokenB: Token,
   fee: FeeAmount,
@@ -50,6 +51,7 @@ const NO_TICK_DATA_PROVIDER_DEFAULT = new NoTickDataProvider();
 export class Pool {
   // public readonly id: number;
   public readonly id: number;
+  public readonly active: boolean;
   public readonly tokenA: Token;
   public readonly tokenB: Token;
   public readonly fee: FeeAmount;
@@ -83,6 +85,7 @@ export class Pool {
    */
   public constructor({
     id,
+    active,
     tokenA,
     tokenB,
     fee,
@@ -108,6 +111,7 @@ export class Pool {
     // always create a copy of the list since we want the pool's tick list to be immutable
     this.id = id;
     this.fee = fee;
+    this.active = active;
     this.sqrtPriceX64 = JSBI.BigInt(sqrtPriceX64);
     this.liquidity = JSBI.BigInt(liquidity);
     this.tickCurrent = tickCurrent;
@@ -380,6 +384,7 @@ export class Pool {
       id: pool.id,
       tokenA: Token.toJSON(pool.tokenA),
       tokenB: Token.toJSON(pool.tokenB),
+      active: pool.active,
       fee: pool.fee,
       sqrtPriceX64: pool.sqrtPriceX64.toString(),
       liquidity: pool.liquidity.toString(),
@@ -395,6 +400,7 @@ export class Pool {
   static fromJSON(json: any): Pool {
     return new Pool({
       id: json.id,
+      active: json.active,
       tokenA: Token.fromJSON(json.tokenA),
       tokenB: Token.fromJSON(json.tokenB),
       fee: json.fee,

package/src/entities/position.ts

@@ -234,6 +234,7 @@ export class Position {
     // construct counterfactual pools
     const poolLower = new Pool({
       id: this.pool.id,
+      active: this.pool.active,
       tokenA: this.pool.tokenA,
       tokenB: this.pool.tokenB,
       fee: this.pool.fee,
@@ -246,6 +247,7 @@ export class Position {
     });
     const poolUpper = new Pool({
       id: this.pool.id,
+      active: this.pool.active,
       tokenA: this.pool.tokenA,
       tokenB: this.pool.tokenB,
       fee: this.pool.fee,
@@ -319,6 +321,7 @@ export class Position {
     // construct counterfactual pools
     const poolLower = new Pool({
       id: this.pool.id,
+      active: this.pool.active,
       tokenA: this.pool.tokenA,
       tokenB: this.pool.tokenB,
       fee: this.pool.fee,
@@ -331,6 +334,7 @@ export class Position {
     });
     const poolUpper = new Pool({
       id: this.pool.id,
+      active: this.pool.active,
       tokenA: this.pool.tokenA,
       tokenB: this.pool.tokenB,
       fee: this.pool.fee,

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>
@@ -493,9 +502,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
       const trade = Trade.fromRoute(route, currencyAmountIn, TradeType.EXACT_INPUT)
 
       // 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,
@@ -519,9 +526,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     for (const route of routes) {
       const trade = Trade.fromRoute(route, currencyAmountOut, TradeType.EXACT_OUTPUT)
 
-      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
-        continue
-      }
+      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue
 
       sortedInsert(
         bestTrades,
@@ -533,4 +538,41 @@ 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.EXACT_INPUT> | 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) {
+        const trade = Trade.fromRoute(route, splitAmount, tradeType, percent)
+        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: TradeType.EXACT_INPUT }
+    )
+  }
 }

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,21 +6,35 @@ 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 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 tradeType = trade.tradeType == TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout'
+
+  const swaps = trade.swaps.map(({ route, percent, inputAmount, outputAmount }) => {
+    route = route.pools.map(p => p.id)
+
+    let minReceived = outputAmount
+
+    if (trade.tradeType === TradeType.EXACT_INPUT) {
+      minReceived = outputAmount.multiply(new Percent(1).subtract(slippage))
+    }
+
+    const input = inputAmount.toSignificant()
+    const output = outputAmount.toSignificant()
+
+    const memo = `${tradeType}#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`
+    return { input, output, percent, memo }
+  })
 
   const result = {
+    swaps,
     input: trade.inputAmount.toFixed(),
     output: trade.outputAmount.toFixed(),
     minReceived: minReceived.toFixed(),
     maxSent: maxSent.toFixed(),
     priceImpact: trade.priceImpact.toSignificant(2),
-    memo,
-    route,
+
+    executionPriceStr: trade.executionPrice.toFixed(),
     executionPrice: {
       numerator: trade.executionPrice.numerator.toString(),
       denominator: trade.executionPrice.denominator.toString()

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