@synthra-swap/smart-order-router 3.15.0

package/build/main/routers/alpha-router/functions/best-swap-route.js

@@ -0,0 +1,364 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestSwapRouteBy = exports.getBestSwapRoute = void 0;
+const bignumber_1 = require("@ethersproject/bignumber");
+const router_sdk_1 = require("@uniswap/router-sdk");
+const sdk_core_1 = require("@synthra-swap/sdk-core");
+const jsbi_1 = __importDefault(require("jsbi"));
+const lodash_1 = __importDefault(require("lodash"));
+const fixed_reverse_heap_1 = __importDefault(require("mnemonist/fixed-reverse-heap"));
+const queue_1 = __importDefault(require("mnemonist/queue"));
+const util_1 = require("../../../util");
+const amounts_1 = require("../../../util/amounts");
+const log_1 = require("../../../util/log");
+const metric_1 = require("../../../util/metric");
+const routes_1 = require("../../../util/routes");
+const gas_models_1 = require("../gas-models");
+async function getBestSwapRoute(amount, percents, routesWithValidQuotes, routeType, chainId, routingConfig, gasModel) {
+    const now = Date.now();
+    const { forceMixedRoutes } = routingConfig;
+    /// Like with forceCrossProtocol, we apply that logic here when determining the bestSwapRoute
+    if (forceMixedRoutes) {
+        log_1.log.info({
+            forceMixedRoutes: forceMixedRoutes,
+        }, 'Forcing mixed routes by filtering out other route types');
+        routesWithValidQuotes = lodash_1.default.filter(routesWithValidQuotes, (quotes) => {
+            return quotes.protocol === router_sdk_1.Protocol.MIXED;
+        });
+        if (!routesWithValidQuotes) {
+            return null;
+        }
+    }
+    // Build a map of percentage of the input to list of valid quotes.
+    // Quotes can be null for a variety of reasons (not enough liquidity etc), so we drop them here too.
+    const percentToQuotes = {};
+    for (const routeWithValidQuote of routesWithValidQuotes) {
+        if (!percentToQuotes[routeWithValidQuote.percent]) {
+            percentToQuotes[routeWithValidQuote.percent] = [];
+        }
+        percentToQuotes[routeWithValidQuote.percent].push(routeWithValidQuote);
+    }
+    metric_1.metric.putMetric('BuildRouteWithValidQuoteObjects', Date.now() - now, metric_1.MetricLoggerUnit.Milliseconds);
+    // Given all the valid quotes for each percentage find the optimal route.
+    const swapRoute = await getBestSwapRouteBy(routeType, percentToQuotes, percents, chainId, (rq) => rq.quoteAdjustedForGas, routingConfig, gasModel);
+    // It is possible we were unable to find any valid route given the quotes.
+    if (!swapRoute) {
+        return null;
+    }
+    // Due to potential loss of precision when taking percentages of the input it is possible that the sum of the amounts of each
+    // route of our optimal quote may not add up exactly to exactIn or exactOut.
+    //
+    // We check this here, and if there is a mismatch
+    // add the missing amount to a random route. The missing amount size should be neglible so the quote should still be highly accurate.
+    const { routes: routeAmounts } = swapRoute;
+    const totalAmount = lodash_1.default.reduce(routeAmounts, (total, routeAmount) => total.add(routeAmount.amount), amounts_1.CurrencyAmount.fromRawAmount(routeAmounts[0].amount.currency, 0));
+    const missingAmount = amount.subtract(totalAmount);
+    if (missingAmount.greaterThan(0)) {
+        log_1.log.info({
+            missingAmount: missingAmount.quotient.toString(),
+        }, `Optimal route's amounts did not equal exactIn/exactOut total. Adding missing amount to last route in array.`);
+        routeAmounts[routeAmounts.length - 1].amount =
+            routeAmounts[routeAmounts.length - 1].amount.add(missingAmount);
+    }
+    log_1.log.info({
+        routes: (0, routes_1.routeAmountsToString)(routeAmounts),
+        numSplits: routeAmounts.length,
+        amount: amount.toExact(),
+        quote: swapRoute.quote.toExact(),
+        quoteGasAdjusted: swapRoute.quoteGasAdjusted.toFixed(Math.min(swapRoute.quoteGasAdjusted.currency.decimals, 2)),
+        estimatedGasUSD: swapRoute.estimatedGasUsedUSD.toFixed(Math.min(swapRoute.estimatedGasUsedUSD.currency.decimals, 2)),
+        estimatedGasToken: swapRoute.estimatedGasUsedQuoteToken.toFixed(Math.min(swapRoute.estimatedGasUsedQuoteToken.currency.decimals, 2)),
+    }, `Found best swap route. ${routeAmounts.length} split.`);
+    return swapRoute;
+}
+exports.getBestSwapRoute = getBestSwapRoute;
+async function getBestSwapRouteBy(routeType, percentToQuotes, percents, chainId, by, routingConfig, gasModel) {
+    var _a;
+    // Build a map of percentage to sorted list of quotes, with the biggest quote being first in the list.
+    const percentToSortedQuotes = lodash_1.default.mapValues(percentToQuotes, (routeQuotes) => {
+        return routeQuotes.sort((routeQuoteA, routeQuoteB) => {
+            if (routeType == sdk_core_1.TradeType.EXACT_INPUT) {
+                return by(routeQuoteA).greaterThan(by(routeQuoteB)) ? -1 : 1;
+            }
+            else {
+                return by(routeQuoteA).lessThan(by(routeQuoteB)) ? -1 : 1;
+            }
+        });
+    });
+    const quoteCompFn = routeType == sdk_core_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;
+    // Min-heap for tracking the 5 best swaps given some number of splits.
+    const bestSwapsPerSplit = new fixed_reverse_heap_1.default(Array, (a, b) => {
+        return quoteCompFn(a.quote, b.quote) ? -1 : 1;
+    }, 3);
+    const { minSplits, maxSplits, forceCrossProtocol } = routingConfig;
+    if (!percentToSortedQuotes[100] || minSplits > 1 || forceCrossProtocol) {
+        log_1.log.info({
+            percentToSortedQuotes: lodash_1.default.mapValues(percentToSortedQuotes, (p) => p.length),
+        }, 'Did not find a valid route without any splits. Continuing search anyway.');
+    }
+    else {
+        bestQuote = by(percentToSortedQuotes[100][0]);
+        bestSwap = [percentToSortedQuotes[100][0]];
+        for (const routeWithQuote of percentToSortedQuotes[100].slice(0, 5)) {
+            bestSwapsPerSplit.push({
+                quote: by(routeWithQuote),
+                routes: [routeWithQuote],
+            });
+        }
+    }
+    // We do a BFS. Each additional node in a path represents us adding an additional split to the route.
+    const queue = new queue_1.default();
+    // First we seed BFS queue with the best quotes for each percentage.
+    // i.e. [best quote when sending 10% of amount, best quote when sending 20% of amount, ...]
+    // We will explore the various combinations from each node.
+    for (let i = percents.length; i >= 0; i--) {
+        const percent = percents[i];
+        if (!percentToSortedQuotes[percent]) {
+            continue;
+        }
+        queue.enqueue({
+            curRoutes: [percentToSortedQuotes[percent][0]],
+            percentIndex: i,
+            remainingPercent: 100 - percent,
+            special: false,
+        });
+        if (!percentToSortedQuotes[percent] ||
+            !percentToSortedQuotes[percent][1]) {
+            continue;
+        }
+        queue.enqueue({
+            curRoutes: [percentToSortedQuotes[percent][1]],
+            percentIndex: i,
+            remainingPercent: 100 - percent,
+            special: true,
+        });
+    }
+    let splits = 1;
+    let startedSplit = Date.now();
+    while (queue.size > 0) {
+        metric_1.metric.putMetric(`Split${splits}Done`, Date.now() - startedSplit, metric_1.MetricLoggerUnit.Milliseconds);
+        startedSplit = Date.now();
+        log_1.log.info({
+            top5: lodash_1.default.map(Array.from(bestSwapsPerSplit.consume()), (q) => `${q.quote.toExact()} (${(0, lodash_1.default)(q.routes)
+                .map((r) => r.toString())
+                .join(', ')})`),
+            onQueue: queue.size,
+        }, `Top 3 with ${splits} splits`);
+        bestSwapsPerSplit.clear();
+        // Size of the queue at this point is the number of potential routes we are investigating for the given number of splits.
+        let layer = queue.size;
+        splits++;
+        // If we didn't improve our quote by adding another split, very unlikely to improve it by splitting more after that.
+        if (splits >= 3 && bestSwap && bestSwap.length < splits - 1) {
+            break;
+        }
+        if (splits > maxSplits) {
+            log_1.log.info('Max splits reached. Stopping search.');
+            metric_1.metric.putMetric(`MaxSplitsHitReached`, 1, metric_1.MetricLoggerUnit.Count);
+            break;
+        }
+        while (layer > 0) {
+            layer--;
+            const { remainingPercent, curRoutes, percentIndex, special } = queue.dequeue();
+            // For all other percentages, add a new potential route.
+            // E.g. if our current aggregated route if missing 50%, we will create new nodes and add to the queue for:
+            // 50% + new 10% route, 50% + new 20% route, etc.
+            for (let i = percentIndex; i >= 0; i--) {
+                const percentA = percents[i];
+                if (percentA > remainingPercent) {
+                    continue;
+                }
+                // At some point the amount * percentage is so small that the quoter is unable to get
+                // a quote. In this case there could be no quotes for that percentage.
+                if (!percentToSortedQuotes[percentA]) {
+                    continue;
+                }
+                const candidateRoutesA = percentToSortedQuotes[percentA];
+                // Find the best route in the complimentary percentage that doesn't re-use a pool already
+                // used in the current route. Re-using pools is not allowed as each swap through a pool changes its liquidity,
+                // so it would make the quotes inaccurate.
+                const routeWithQuoteA = findFirstRouteNotUsingUsedPools(curRoutes, candidateRoutesA, forceCrossProtocol);
+                if (!routeWithQuoteA) {
+                    continue;
+                }
+                const remainingPercentNew = remainingPercent - percentA;
+                const curRoutesNew = [...curRoutes, routeWithQuoteA];
+                // If we've found a route combination that uses all 100%, and it has at least minSplits, update our best route.
+                if (remainingPercentNew == 0 && splits >= minSplits) {
+                    const quotesNew = lodash_1.default.map(curRoutesNew, (r) => by(r));
+                    const quoteNew = sumFn(quotesNew);
+                    let gasCostL1QuoteToken = amounts_1.CurrencyAmount.fromRawAmount(quoteNew.currency, 0);
+                    if (util_1.HAS_L1_FEE.includes(chainId)) {
+                        const onlyV3Routes = curRoutesNew.every((route) => route.protocol == router_sdk_1.Protocol.V3);
+                        if (gasModel == undefined || !onlyV3Routes) {
+                            throw new Error("Can't compute L1 gas fees.");
+                        }
+                        else {
+                            const gasCostL1 = await gasModel.calculateL1GasFees(curRoutesNew);
+                            gasCostL1QuoteToken = gasCostL1.gasCostL1QuoteToken;
+                        }
+                    }
+                    const quoteAfterL1Adjust = routeType == sdk_core_1.TradeType.EXACT_INPUT
+                        ? quoteNew.subtract(gasCostL1QuoteToken)
+                        : quoteNew.add(gasCostL1QuoteToken);
+                    bestSwapsPerSplit.push({
+                        quote: quoteAfterL1Adjust,
+                        routes: curRoutesNew,
+                    });
+                    if (!bestQuote || quoteCompFn(quoteAfterL1Adjust, bestQuote)) {
+                        bestQuote = quoteAfterL1Adjust;
+                        bestSwap = curRoutesNew;
+                        // Temporary experiment.
+                        if (special) {
+                            metric_1.metric.putMetric(`BestSwapNotPickingBestForPercent`, 1, metric_1.MetricLoggerUnit.Count);
+                        }
+                    }
+                }
+                else {
+                    queue.enqueue({
+                        curRoutes: curRoutesNew,
+                        remainingPercent: remainingPercentNew,
+                        percentIndex: i,
+                        special,
+                    });
+                }
+            }
+        }
+    }
+    if (!bestSwap) {
+        log_1.log.info(`Could not find a valid swap`);
+        return undefined;
+    }
+    const postSplitNow = Date.now();
+    let quoteGasAdjusted = sumFn(lodash_1.default.map(bestSwap, (routeWithValidQuote) => routeWithValidQuote.quoteAdjustedForGas));
+    // this calculates the base gas used
+    // if on L1, its the estimated gas used based on hops and ticks across all the routes
+    // if on L2, its the gas used on the L2 based on hops and ticks across all the routes
+    const estimatedGasUsed = (0, lodash_1.default)(bestSwap)
+        .map((routeWithValidQuote) => routeWithValidQuote.gasEstimate)
+        .reduce((sum, routeWithValidQuote) => sum.add(routeWithValidQuote), bignumber_1.BigNumber.from(0));
+    if (!gas_models_1.usdGasTokensByChain[chainId] || !gas_models_1.usdGasTokensByChain[chainId][0]) {
+        // Each route can use a different stablecoin to account its gas costs.
+        // They should all be pegged, and this is just an estimate, so we do a merge
+        // to an arbitrary stable.
+        throw new Error(`Could not find a USD token for computing gas costs on ${chainId}`);
+    }
+    const usdToken = gas_models_1.usdGasTokensByChain[chainId][0];
+    const usdTokenDecimals = usdToken.decimals;
+    // if on L2, calculate the L1 security fee
+    let gasCostsL1ToL2 = {
+        gasUsedL1: bignumber_1.BigNumber.from(0),
+        gasCostL1USD: amounts_1.CurrencyAmount.fromRawAmount(usdToken, 0),
+        gasCostL1QuoteToken: amounts_1.CurrencyAmount.fromRawAmount(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+        (_a = bestSwap[0]) === null || _a === void 0 ? void 0 : _a.quoteToken, 0),
+    };
+    // If swapping on an L2 that includes a L1 security fee, calculate the fee and include it in the gas adjusted quotes
+    if (util_1.HAS_L1_FEE.includes(chainId)) {
+        // ensure the gasModel exists and that the swap route is a v3 only route
+        const onlyV3Routes = bestSwap.every((route) => route.protocol == router_sdk_1.Protocol.V3);
+        if (gasModel == undefined || !onlyV3Routes) {
+            throw new Error("Can't compute L1 gas fees.");
+        }
+        else {
+            gasCostsL1ToL2 = await gasModel.calculateL1GasFees(bestSwap);
+        }
+    }
+    const { gasCostL1USD, gasCostL1QuoteToken } = gasCostsL1ToL2;
+    // For each gas estimate, normalize decimals to that of the chosen usd token.
+    const estimatedGasUsedUSDs = (0, lodash_1.default)(bestSwap)
+        .map((routeWithValidQuote) => {
+        // TODO: will error if gasToken has decimals greater than usdToken
+        const decimalsDiff = usdTokenDecimals - routeWithValidQuote.gasCostInUSD.currency.decimals;
+        if (decimalsDiff == 0) {
+            return amounts_1.CurrencyAmount.fromRawAmount(usdToken, routeWithValidQuote.gasCostInUSD.quotient);
+        }
+        return amounts_1.CurrencyAmount.fromRawAmount(usdToken, jsbi_1.default.multiply(routeWithValidQuote.gasCostInUSD.quotient, jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(decimalsDiff))));
+    })
+        .value();
+    let estimatedGasUsedUSD = sumFn(estimatedGasUsedUSDs);
+    // if they are different usd pools, convert to the usdToken
+    if (estimatedGasUsedUSD.currency != gasCostL1USD.currency) {
+        const decimalsDiff = usdTokenDecimals - gasCostL1USD.currency.decimals;
+        estimatedGasUsedUSD = estimatedGasUsedUSD.add(amounts_1.CurrencyAmount.fromRawAmount(usdToken, jsbi_1.default.multiply(gasCostL1USD.quotient, jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(decimalsDiff)))));
+    }
+    else {
+        estimatedGasUsedUSD = estimatedGasUsedUSD.add(gasCostL1USD);
+    }
+    log_1.log.info({
+        estimatedGasUsedUSD: estimatedGasUsedUSD.toExact(),
+        normalizedUsdToken: usdToken,
+        routeUSDGasEstimates: lodash_1.default.map(bestSwap, (b) => `${b.percent}% ${(0, routes_1.routeToString)(b.route)} ${b.gasCostInUSD.toExact()}`),
+        flatL1GasCostUSD: gasCostL1USD.toExact(),
+    }, 'USD gas estimates of best route');
+    const estimatedGasUsedQuoteToken = sumFn(lodash_1.default.map(bestSwap, (routeWithValidQuote) => routeWithValidQuote.gasCostInToken)).add(gasCostL1QuoteToken);
+    const quote = sumFn(lodash_1.default.map(bestSwap, (routeWithValidQuote) => routeWithValidQuote.quote));
+    // Adjust the quoteGasAdjusted for the l1 fee
+    if (routeType == sdk_core_1.TradeType.EXACT_INPUT) {
+        const quoteGasAdjustedForL1 = quoteGasAdjusted.subtract(gasCostL1QuoteToken);
+        quoteGasAdjusted = quoteGasAdjustedForL1;
+    }
+    else {
+        const quoteGasAdjustedForL1 = quoteGasAdjusted.add(gasCostL1QuoteToken);
+        quoteGasAdjusted = quoteGasAdjustedForL1;
+    }
+    const routeWithQuotes = bestSwap.sort((routeAmountA, routeAmountB) => routeAmountB.amount.greaterThan(routeAmountA.amount) ? 1 : -1);
+    metric_1.metric.putMetric('PostSplitDone', Date.now() - postSplitNow, metric_1.MetricLoggerUnit.Milliseconds);
+    return {
+        quote,
+        quoteGasAdjusted,
+        estimatedGasUsed,
+        estimatedGasUsedUSD,
+        estimatedGasUsedQuoteToken,
+        routes: routeWithQuotes,
+    };
+}
+exports.getBestSwapRouteBy = getBestSwapRouteBy;
+// We do not allow pools to be re-used across split routes, as swapping through a pool changes the pools state.
+// Given a list of used routes, this function finds the first route in the list of candidate routes that does not re-use an already used pool.
+const findFirstRouteNotUsingUsedPools = (usedRoutes, candidateRouteQuotes, forceCrossProtocol) => {
+    const poolAddressSet = new Set();
+    const usedPoolAddresses = (0, lodash_1.default)(usedRoutes)
+        .flatMap((r) => r.poolAddresses)
+        .value();
+    for (const poolAddress of usedPoolAddresses) {
+        poolAddressSet.add(poolAddress);
+    }
+    const protocolsSet = new Set();
+    const usedProtocols = (0, lodash_1.default)(usedRoutes)
+        .flatMap((r) => r.protocol)
+        .uniq()
+        .value();
+    for (const protocol of usedProtocols) {
+        protocolsSet.add(protocol);
+    }
+    for (const routeQuote of candidateRouteQuotes) {
+        const { poolAddresses, protocol } = routeQuote;
+        if (poolAddresses.some((poolAddress) => poolAddressSet.has(poolAddress))) {
+            continue;
+        }
+        // This code is just for debugging. Allows us to force a cross-protocol split route by skipping
+        // consideration of routes that come from the same protocol as a used route.
+        const needToForce = forceCrossProtocol && protocolsSet.size == 1;
+        if (needToForce && protocolsSet.has(protocol)) {
+            continue;
+        }
+        return routeQuote;
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"best-swap-route.js","sourceRoot":"","sources":["../../../../../src/routers/alpha-router/functions/best-swap-route.ts"],"names":[],"mappings":"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"}

package/build/main/routers/alpha-router/functions/calculate-ratio-amount-in.d.ts

@@ -0,0 +1,3 @@
+import { Fraction } from '@synthra-swap/sdk-core';
+import { CurrencyAmount } from '../../../util/amounts';
+export declare function calculateRatioAmountIn(optimalRatio: Fraction, inputTokenPrice: Fraction, inputBalance: CurrencyAmount, outputBalance: CurrencyAmount): CurrencyAmount;

package/build/main/routers/alpha-router/functions/calculate-ratio-amount-in.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRatioAmountIn = void 0;
+const sdk_core_1 = require("@synthra-swap/sdk-core");
+const amounts_1 = require("../../../util/amounts");
+function calculateRatioAmountIn(optimalRatio, inputTokenPrice, inputBalance, outputBalance) {
+    // formula: amountToSwap = (inputBalance - (optimalRatio * outputBalance)) / ((optimalRatio * inputTokenPrice) + 1))
+    const amountToSwapRaw = new sdk_core_1.Fraction(inputBalance.quotient)
+        .subtract(optimalRatio.multiply(outputBalance.quotient))
+        .divide(optimalRatio.multiply(inputTokenPrice).add(1));
+    if (amountToSwapRaw.lessThan(0)) {
+        // should never happen since we do checks before calling in
+        throw new Error('routeToRatio: insufficient input token amount');
+    }
+    return amounts_1.CurrencyAmount.fromRawAmount(inputBalance.currency, amountToSwapRaw.quotient);
+}
+exports.calculateRatioAmountIn = calculateRatioAmountIn;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yb3V0ZXJzL2FscGhhLXJvdXRlci9mdW5jdGlvbnMvY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxnREFBNkM7QUFFN0MsbURBQXVEO0FBRXZELFNBQWdCLHNCQUFzQixDQUNwQyxZQUFzQixFQUN0QixlQUF5QixFQUN6QixZQUE0QixFQUM1QixhQUE2QjtJQUU3QixvSEFBb0g7SUFDcEgsTUFBTSxlQUFlLEdBQUcsSUFBSSxtQkFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUM7U0FDeEQsUUFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1NBQ3ZELE1BQU0sQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXpELElBQUksZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsRUFBRTtRQUMvQiwyREFBMkQ7UUFDM0QsTUFBTSxJQUFJLEtBQUssQ0FBQywrQ0FBK0MsQ0FBQyxDQUFDO0tBQ2xFO0lBRUQsT0FBTyx3QkFBYyxDQUFDLGFBQWEsQ0FDakMsWUFBWSxDQUFDLFFBQVEsRUFDckIsZUFBZSxDQUFDLFFBQVEsQ0FDekIsQ0FBQztBQUNKLENBQUM7QUFwQkQsd0RBb0JDIn0=

package/build/main/routers/alpha-router/functions/compute-all-routes.d.ts

@@ -0,0 +1,8 @@
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool } from '@uniswap/v3-sdk';
+import { Token } from '@synthra-swap/sdk-core';
+import { MixedRoute, V2Route, V3Route } from '../../router';
+export declare function computeAllV3Routes(tokenIn: Token, tokenOut: Token, pools: Pool[], maxHops: number): V3Route[];
+export declare function computeAllV2Routes(tokenIn: Token, tokenOut: Token, pools: Pair[], maxHops: number): V2Route[];
+export declare function computeAllMixedRoutes(tokenIn: Token, tokenOut: Token, parts: (Pool | Pair)[], maxHops: number): MixedRoute[];
+export declare function computeAllRoutes<TPool extends Pair | Pool, TRoute extends V3Route | V2Route | MixedRoute>(tokenIn: Token, tokenOut: Token, buildRoute: (route: TPool[], tokenIn: Token, tokenOut: Token) => TRoute, pools: TPool[], maxHops: number): TRoute[];

package/build/main/routers/alpha-router/functions/compute-all-routes.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAllRoutes = exports.computeAllMixedRoutes = exports.computeAllV2Routes = exports.computeAllV3Routes = void 0;
+const v2_sdk_1 = require("@uniswap/v2-sdk");
+const v3_sdk_1 = require("@uniswap/v3-sdk");
+const log_1 = require("../../../util/log");
+const routes_1 = require("../../../util/routes");
+const router_1 = require("../../router");
+function computeAllV3Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.V3Route(route, tokenIn, tokenOut);
+    }, pools, maxHops);
+}
+exports.computeAllV3Routes = computeAllV3Routes;
+function computeAllV2Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.V2Route(route, tokenIn, tokenOut);
+    }, pools, maxHops);
+}
+exports.computeAllV2Routes = computeAllV2Routes;
+function computeAllMixedRoutes(tokenIn, tokenOut, parts, maxHops) {
+    const routesRaw = computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.MixedRoute(route, tokenIn, tokenOut);
+    }, parts, maxHops);
+    /// filter out pure v3 and v2 routes
+    return routesRaw.filter((route) => {
+        return (!route.pools.every((pool) => pool instanceof v3_sdk_1.Pool) &&
+            !route.pools.every((pool) => pool instanceof v2_sdk_1.Pair));
+    });
+}
+exports.computeAllMixedRoutes = computeAllMixedRoutes;
+function computeAllRoutes(tokenIn, tokenOut, buildRoute, pools, maxHops) {
+    var _a;
+    const poolsUsed = Array(pools.length).fill(false);
+    const routes = [];
+    const computeRoutes = (tokenIn, tokenOut, currentRoute, poolsUsed, _previousTokenOut) => {
+        if (currentRoute.length > maxHops) {
+            return;
+        }
+        if (currentRoute.length > 0 &&
+            currentRoute[currentRoute.length - 1].involvesToken(tokenOut)) {
+            routes.push(buildRoute([...currentRoute], tokenIn, tokenOut));
+            return;
+        }
+        for (let i = 0; i < pools.length; i++) {
+            if (poolsUsed[i]) {
+                continue;
+            }
+            const curPool = pools[i];
+            const previousTokenOut = _previousTokenOut ? _previousTokenOut : tokenIn;
+            if (!curPool.involvesToken(previousTokenOut)) {
+                continue;
+            }
+            const currentTokenOut = curPool.token0.equals(previousTokenOut)
+                ? curPool.token1
+                : curPool.token0;
+            currentRoute.push(curPool);
+            poolsUsed[i] = true;
+            computeRoutes(tokenIn, tokenOut, currentRoute, poolsUsed, currentTokenOut);
+            poolsUsed[i] = false;
+            currentRoute.pop();
+        }
+    };
+    computeRoutes(tokenIn, tokenOut, [], poolsUsed);
+    log_1.log.info({
+        routes: routes.map(routes_1.routeToString),
+        pools: pools.map(routes_1.poolToString),
+    }, `Computed ${routes.length} possible routes for type ${(_a = routes[0]) === null || _a === void 0 ? void 0 : _a.protocol}.`);
+    return routes;
+}
+exports.computeAllRoutes = computeAllRoutes;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/routers/alpha-router/functions/get-candidate-pools.d.ts

@@ -0,0 +1,78 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { Token, TradeType } from '@synthra-swap/sdk-core';
+import { ITokenListProvider, IV2SubgraphProvider, V2SubgraphPool } from '../../../providers';
+import { ITokenProvider } from '../../../providers/token-provider';
+import { IV2PoolProvider, V2PoolAccessor } from '../../../providers/v2/pool-provider';
+import { IV3PoolProvider, V3PoolAccessor } from '../../../providers/v3/pool-provider';
+import { IV3SubgraphProvider, V3SubgraphPool } from '../../../providers/v3/subgraph-provider';
+import { SupportedIds } from '../../../util';
+import { AlphaRouterConfig } from '../alpha-router';
+export declare type PoolId = {
+    id: string;
+};
+export declare type CandidatePoolsBySelectionCriteria = {
+    protocol: Protocol;
+    selections: CandidatePoolsSelections;
+};
+export declare type CandidatePoolsSelections = {
+    topByBaseWithTokenIn: PoolId[];
+    topByBaseWithTokenOut: PoolId[];
+    topByDirectSwapPool: PoolId[];
+    topByEthQuoteTokenPool: PoolId[];
+    topByTVL: PoolId[];
+    topByTVLUsingTokenIn: PoolId[];
+    topByTVLUsingTokenOut: PoolId[];
+    topByTVLUsingTokenInSecondHops: PoolId[];
+    topByTVLUsingTokenOutSecondHops: PoolId[];
+};
+export declare type V3GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV3SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV3PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: SupportedIds;
+};
+export declare type V2GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV2SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV2PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: SupportedIds;
+};
+export declare type MixedRouteGetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    v2subgraphProvider: IV2SubgraphProvider;
+    v3subgraphProvider: IV3SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    v2poolProvider: IV2PoolProvider;
+    v3poolProvider: IV3PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: SupportedIds;
+};
+export declare function getV3CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: V3GetCandidatePoolsParams): Promise<{
+    poolAccessor: V3PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V3SubgraphPool[];
+}>;
+export declare function getV2CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: V2GetCandidatePoolsParams): Promise<{
+    poolAccessor: V2PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V2SubgraphPool[];
+}>;
+export declare function getMixedRouteCandidatePools({ tokenIn, tokenOut, routeType, routingConfig, v3subgraphProvider, v2subgraphProvider, tokenProvider, v3poolProvider, v2poolProvider, blockedTokenListProvider, chainId, }: MixedRouteGetCandidatePoolsParams): Promise<{
+    V2poolAccessor: V2PoolAccessor;
+    V3poolAccessor: V3PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: (V2SubgraphPool | V3SubgraphPool)[];
+}>;