@kumbaya_xyz/smart-order-router 4.22.38

package/build/module/routers/legacy-router/legacy-router.d.ts

@@ -0,0 +1,41 @@
+import { ChainId, Currency, TradeType } from '@uniswap/sdk-core';
+import { IOnChainQuoteProvider } from '../../providers';
+import { IMulticallProvider } from '../../providers/multicall-provider';
+import { ITokenProvider } from '../../providers/token-provider';
+import { IV3PoolProvider } from '../../providers/v3/pool-provider';
+import { CurrencyAmount } from '../../util/amounts';
+import { SwapOptionsSwapRouter02, SwapRoute } from '../router';
+export type LegacyRouterParams = {
+    chainId: ChainId;
+    multicall2Provider: IMulticallProvider;
+    poolProvider: IV3PoolProvider;
+    quoteProvider: IOnChainQuoteProvider;
+    tokenProvider: ITokenProvider;
+};
+export type LegacyRoutingConfig = {
+    blockNumber?: number;
+};
+/**
+ * Replicates the router implemented in the V3 interface.
+ * Code is mostly a copy from https://github.com/Uniswap/uniswap-interface/blob/0190b5a408c13016c87e1030ffc59326c085f389/src/hooks/useBestV3Trade.ts#L22-L23
+ * with React/Redux hooks removed, and refactoring to allow re-use in other routers.
+ */
+export declare class LegacyRouter {
+    protected chainId: ChainId;
+    protected multicall2Provider: IMulticallProvider;
+    protected poolProvider: IV3PoolProvider;
+    protected quoteProvider: IOnChainQuoteProvider;
+    protected tokenProvider: ITokenProvider;
+    constructor({ chainId, multicall2Provider, poolProvider, quoteProvider, tokenProvider, }: LegacyRouterParams);
+    route(amount: CurrencyAmount, quoteCurrency: Currency, swapType: TradeType, swapConfig?: SwapOptionsSwapRouter02, partialRoutingConfig?: Partial<LegacyRoutingConfig>): Promise<SwapRoute | null>;
+    routeExactIn(currencyIn: Currency, currencyOut: Currency, amountIn: CurrencyAmount, swapConfig?: SwapOptionsSwapRouter02, routingConfig?: LegacyRoutingConfig): Promise<SwapRoute | null>;
+    routeExactOut(currencyIn: Currency, currencyOut: Currency, amountOut: CurrencyAmount, swapConfig?: SwapOptionsSwapRouter02, routingConfig?: LegacyRoutingConfig): Promise<SwapRoute | null>;
+    private findBestRouteExactIn;
+    private findBestRouteExactOut;
+    private getBestQuote;
+    private getAllRoutes;
+    private getAllPossiblePairings;
+    private computeAllRoutes;
+    private buildTrade;
+    private buildMethodParameters;
+}

package/build/module/routers/legacy-router/legacy-router.js

@@ -0,0 +1,292 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Logger } from '@ethersproject/logger';
+import { SwapRouter, Trade } from '@uniswap/router-sdk';
+import { TradeType } from '@uniswap/sdk-core';
+import { FeeAmount, Route } from '@uniswap/v3-sdk';
+import _ from 'lodash';
+import { DAI_MAINNET, USDC_MAINNET, } from '../../providers/token-provider';
+import { SWAP_ROUTER_02_ADDRESSES } from '../../util';
+import { CurrencyAmount } from '../../util/amounts';
+import { log } from '../../util/log';
+import { routeToString } from '../../util/routes';
+import { V3RouteWithValidQuote } from '../alpha-router';
+import { V3Route } from '../router';
+import { ADDITIONAL_BASES, BASES_TO_CHECK_TRADES_AGAINST, CUSTOM_BASES, } from './bases';
+// Interface defaults to 2.
+const MAX_HOPS = 2;
+/**
+ * Replicates the router implemented in the V3 interface.
+ * Code is mostly a copy from https://github.com/Uniswap/uniswap-interface/blob/0190b5a408c13016c87e1030ffc59326c085f389/src/hooks/useBestV3Trade.ts#L22-L23
+ * with React/Redux hooks removed, and refactoring to allow re-use in other routers.
+ */
+export class LegacyRouter {
+    constructor({ chainId, multicall2Provider, poolProvider, quoteProvider, tokenProvider, }) {
+        this.chainId = chainId;
+        this.multicall2Provider = multicall2Provider;
+        this.poolProvider = poolProvider;
+        this.quoteProvider = quoteProvider;
+        this.tokenProvider = tokenProvider;
+    }
+    async route(amount, quoteCurrency, swapType, swapConfig, partialRoutingConfig) {
+        if (swapType == TradeType.EXACT_INPUT) {
+            return this.routeExactIn(amount.currency, quoteCurrency, amount, swapConfig, partialRoutingConfig);
+        }
+        return this.routeExactOut(quoteCurrency, amount.currency, amount, swapConfig, partialRoutingConfig);
+    }
+    async routeExactIn(currencyIn, currencyOut, amountIn, swapConfig, routingConfig) {
+        const tokenIn = currencyIn.wrapped;
+        const tokenOut = currencyOut.wrapped;
+        const routes = await this.getAllRoutes(tokenIn, tokenOut, routingConfig);
+        const routeQuote = await this.findBestRouteExactIn(amountIn, tokenOut, routes, routingConfig);
+        if (!routeQuote) {
+            return null;
+        }
+        const trade = this.buildTrade(currencyIn, currencyOut, TradeType.EXACT_INPUT, routeQuote);
+        return {
+            quote: routeQuote.quote,
+            quoteGasAdjusted: routeQuote.quote,
+            route: [routeQuote],
+            estimatedGasUsed: BigNumber.from(0),
+            estimatedGasUsedQuoteToken: CurrencyAmount.fromFractionalAmount(tokenOut, 0, 1),
+            estimatedGasUsedUSD: CurrencyAmount.fromFractionalAmount(DAI_MAINNET, 0, 1),
+            gasPriceWei: BigNumber.from(0),
+            trade,
+            methodParameters: swapConfig
+                ? {
+                    ...this.buildMethodParameters(trade, swapConfig),
+                    to: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+                }
+                : undefined,
+            blockNumber: BigNumber.from(0),
+        };
+    }
+    async routeExactOut(currencyIn, currencyOut, amountOut, swapConfig, routingConfig) {
+        const tokenIn = currencyIn.wrapped;
+        const tokenOut = currencyOut.wrapped;
+        const routes = await this.getAllRoutes(tokenIn, tokenOut, routingConfig);
+        const routeQuote = await this.findBestRouteExactOut(amountOut, tokenIn, routes, routingConfig);
+        if (!routeQuote) {
+            return null;
+        }
+        const trade = this.buildTrade(currencyIn, currencyOut, TradeType.EXACT_OUTPUT, routeQuote);
+        return {
+            quote: routeQuote.quote,
+            quoteGasAdjusted: routeQuote.quote,
+            route: [routeQuote],
+            estimatedGasUsed: BigNumber.from(0),
+            estimatedGasUsedQuoteToken: CurrencyAmount.fromFractionalAmount(tokenIn, 0, 1),
+            estimatedGasUsedUSD: CurrencyAmount.fromFractionalAmount(DAI_MAINNET, 0, 1),
+            gasPriceWei: BigNumber.from(0),
+            trade,
+            methodParameters: swapConfig
+                ? {
+                    ...this.buildMethodParameters(trade, swapConfig),
+                    to: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+                }
+                : undefined,
+            blockNumber: BigNumber.from(0),
+        };
+    }
+    async findBestRouteExactIn(amountIn, tokenOut, routes, routingConfig) {
+        const { routesWithQuotes: quotesRaw } = await this.quoteProvider.getQuotesManyExactIn([amountIn], routes, {
+            blockNumber: routingConfig === null || routingConfig === void 0 ? void 0 : routingConfig.blockNumber,
+        });
+        const quotes100Percent = _.map(quotesRaw, ([route, quotes]) => { var _a, _b; return `${routeToString(route)} : ${(_b = (_a = quotes[0]) === null || _a === void 0 ? void 0 : _a.quote) === null || _b === void 0 ? void 0 : _b.toString()}`; });
+        log.info({ quotes100Percent }, '100% Quotes');
+        const bestQuote = await this.getBestQuote(routes, quotesRaw, tokenOut, TradeType.EXACT_INPUT);
+        return bestQuote;
+    }
+    async findBestRouteExactOut(amountOut, tokenIn, routes, routingConfig) {
+        const { routesWithQuotes: quotesRaw } = await this.quoteProvider.getQuotesManyExactOut([amountOut], routes, {
+            blockNumber: routingConfig === null || routingConfig === void 0 ? void 0 : routingConfig.blockNumber,
+        });
+        const bestQuote = await this.getBestQuote(routes, quotesRaw, tokenIn, TradeType.EXACT_OUTPUT);
+        return bestQuote;
+    }
+    async getBestQuote(routes, quotesRaw, quoteToken, routeType) {
+        log.debug(`Got ${_.filter(quotesRaw, ([_, quotes]) => !!quotes[0]).length} valid quotes from ${routes.length} possible routes.`);
+        const routeQuotesRaw = [];
+        for (let i = 0; i < quotesRaw.length; i++) {
+            const [route, quotes] = quotesRaw[i];
+            const { quote, amount } = quotes[0];
+            if (!quote) {
+                Logger.globalLogger().debug(`No quote for ${routeToString(route)}`);
+                continue;
+            }
+            routeQuotesRaw.push({ route, quote, amount });
+        }
+        if (routeQuotesRaw.length == 0) {
+            return null;
+        }
+        routeQuotesRaw.sort((routeQuoteA, routeQuoteB) => {
+            if (routeType == TradeType.EXACT_INPUT) {
+                return routeQuoteA.quote.gt(routeQuoteB.quote) ? -1 : 1;
+            }
+            else {
+                return routeQuoteA.quote.lt(routeQuoteB.quote) ? -1 : 1;
+            }
+        });
+        const routeQuotes = _.map(routeQuotesRaw, ({ route, quote, amount }) => {
+            return new V3RouteWithValidQuote({
+                route,
+                rawQuote: quote,
+                amount,
+                percent: 100,
+                gasModel: {
+                    estimateGasCost: () => ({
+                        gasCostInToken: CurrencyAmount.fromRawAmount(quoteToken, 0),
+                        gasCostInUSD: CurrencyAmount.fromRawAmount(USDC_MAINNET, 0),
+                        gasEstimate: BigNumber.from(0),
+                    }),
+                },
+                sqrtPriceX96AfterList: [],
+                initializedTicksCrossedList: [],
+                quoterGasEstimate: BigNumber.from(0),
+                tradeType: routeType,
+                quoteToken,
+                v3PoolProvider: this.poolProvider,
+            });
+        });
+        for (const rq of routeQuotes) {
+            log.debug(`Quote: ${rq.amount.toFixed(Math.min(rq.amount.currency.decimals, 2))} Route: ${routeToString(rq.route)}`);
+        }
+        return routeQuotes[0];
+    }
+    async getAllRoutes(tokenIn, tokenOut, routingConfig) {
+        const tokenPairs = await this.getAllPossiblePairings(tokenIn, tokenOut);
+        const poolAccessor = await this.poolProvider.getPools(tokenPairs, {
+            blockNumber: routingConfig === null || routingConfig === void 0 ? void 0 : routingConfig.blockNumber,
+        });
+        const pools = poolAccessor.getAllPools();
+        const routes = this.computeAllRoutes(tokenIn, tokenOut, pools, this.chainId, [], [], tokenIn, MAX_HOPS);
+        log.info({ routes: _.map(routes, routeToString) }, `Computed ${routes.length} possible routes.`);
+        return routes;
+    }
+    async getAllPossiblePairings(tokenIn, tokenOut) {
+        var _a, _b, _c, _d, _e;
+        const common = (_a = BASES_TO_CHECK_TRADES_AGAINST(this.tokenProvider)[this.chainId]) !== null && _a !== void 0 ? _a : [];
+        const additionalA = (_c = (_b = (await ADDITIONAL_BASES(this.tokenProvider))[this.chainId]) === null || _b === void 0 ? void 0 : _b[tokenIn.address]) !== null && _c !== void 0 ? _c : [];
+        const additionalB = (_e = (_d = (await ADDITIONAL_BASES(this.tokenProvider))[this.chainId]) === null || _d === void 0 ? void 0 : _d[tokenOut.address]) !== null && _e !== void 0 ? _e : [];
+        const bases = [...common, ...additionalA, ...additionalB];
+        const basePairs = _.flatMap(bases, (base) => bases.map((otherBase) => [base, otherBase]));
+        const customBases = (await CUSTOM_BASES(this.tokenProvider))[this.chainId];
+        const allPairs = _([
+            // the direct pair
+            [tokenIn, tokenOut],
+            // token A against all bases
+            ...bases.map((base) => [tokenIn, base]),
+            // token B against all bases
+            ...bases.map((base) => [tokenOut, base]),
+            // each base against all bases
+            ...basePairs,
+        ])
+            .filter((tokens) => Boolean(tokens[0] && tokens[1]))
+            .filter(([tokenA, tokenB]) => tokenA.address !== tokenB.address && !tokenA.equals(tokenB))
+            .filter(([tokenA, tokenB]) => {
+            const customBasesA = customBases === null || customBases === void 0 ? void 0 : customBases[tokenA.address];
+            const customBasesB = customBases === null || customBases === void 0 ? void 0 : customBases[tokenB.address];
+            if (!customBasesA && !customBasesB)
+                return true;
+            if (customBasesA && !customBasesA.find((base) => tokenB.equals(base)))
+                return false;
+            if (customBasesB && !customBasesB.find((base) => tokenA.equals(base)))
+                return false;
+            return true;
+        })
+            .flatMap(([tokenA, tokenB]) => {
+            return [
+                [tokenA, tokenB, FeeAmount.LOW],
+                [tokenA, tokenB, FeeAmount.MEDIUM],
+                [tokenA, tokenB, FeeAmount.HIGH],
+            ];
+        })
+            .value();
+        return allPairs;
+    }
+    computeAllRoutes(tokenIn, tokenOut, pools, chainId, currentPath = [], allPaths = [], startTokenIn = tokenIn, maxHops = 2) {
+        for (const pool of pools) {
+            if (currentPath.indexOf(pool) !== -1 || !pool.involvesToken(tokenIn))
+                continue;
+            const outputToken = pool.token0.equals(tokenIn)
+                ? pool.token1
+                : pool.token0;
+            if (outputToken.equals(tokenOut)) {
+                allPaths.push(new V3Route([...currentPath, pool], startTokenIn, tokenOut));
+            }
+            else if (maxHops > 1) {
+                this.computeAllRoutes(outputToken, tokenOut, pools, chainId, [...currentPath, pool], allPaths, startTokenIn, maxHops - 1);
+            }
+        }
+        return allPaths;
+    }
+    buildTrade(tokenInCurrency, tokenOutCurrency, tradeType, routeAmount) {
+        const { route, amount, quote } = routeAmount;
+        // The route, amount and quote are all in terms of wrapped tokens.
+        // When constructing the Trade object the inputAmount/outputAmount must
+        // use native currencies if necessary. This is so that the Trade knows to wrap/unwrap.
+        if (tradeType == TradeType.EXACT_INPUT) {
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, amount.numerator, amount.denominator);
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, quote.numerator, quote.denominator);
+            const routeCurrency = new Route(route.pools, amountCurrency.currency, quoteCurrency.currency);
+            return new Trade({
+                v4Routes: [],
+                v3Routes: [
+                    {
+                        routev3: routeCurrency,
+                        inputAmount: amountCurrency,
+                        outputAmount: quoteCurrency,
+                    },
+                ],
+                v2Routes: [],
+                tradeType: tradeType,
+            });
+        }
+        else {
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, quote.numerator, quote.denominator);
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, amount.numerator, amount.denominator);
+            const routeCurrency = new Route(route.pools, quoteCurrency.currency, amountCurrency.currency);
+            return new Trade({
+                v4Routes: [],
+                v3Routes: [
+                    {
+                        routev3: routeCurrency,
+                        inputAmount: quoteCurrency,
+                        outputAmount: amountCurrency,
+                    },
+                ],
+                v2Routes: [],
+                tradeType: tradeType,
+            });
+        }
+    }
+    buildMethodParameters(trade, swapConfig) {
+        const { recipient, slippageTolerance, deadline } = swapConfig;
+        const methodParameters = SwapRouter.swapCallParameters(trade, {
+            recipient,
+            slippageTolerance,
+            deadlineOrPreviousBlockhash: deadline,
+            // ...(signatureData
+            //   ? {
+            //       inputTokenPermit:
+            //         'allowed' in signatureData
+            //           ? {
+            //               expiry: signatureData.deadline,
+            //               nonce: signatureData.nonce,
+            //               s: signatureData.s,
+            //               r: signatureData.r,
+            //               v: signatureData.v as any,
+            //             }
+            //           : {
+            //               deadline: signatureData.deadline,
+            //               amount: signatureData.amount,
+            //               s: signatureData.s,
+            //               r: signatureData.r,
+            //               v: signatureData.v as any,
+            //             },
+            //     }
+            //   : {}),
+        });
+        return methodParameters;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"legacy-router.js","sourceRoot":"","sources":["../../../../src/routers/legacy-router/legacy-router.ts"],"names":[],"mappings":"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"}

package/build/module/routers/router.d.ts

@@ -0,0 +1,195 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { CondensedAddLiquidityOptions, MixedRouteSDK, Protocol, TPool, Trade } from '@uniswap/router-sdk';
+import { Currency, Fraction, Percent, Token, TradeType } from '@uniswap/sdk-core';
+import { SwapOptions as UniversalRouterSwapOptions, UniversalRouterVersion } from '@uniswap/universal-router-sdk';
+import { Pair, Route as V2RouteRaw } from '@uniswap/v2-sdk';
+import { Pool, Position, MethodParameters as SDKMethodParameters, Pool as V3Pool, Route as V3RouteRaw } from '@uniswap/v3-sdk';
+import { Pool as V4Pool, Route as V4RouteRaw } from '@uniswap/v4-sdk';
+import { SimulationStatus } from '../providers';
+import { CurrencyAmount } from '../util/amounts';
+import { RouteWithValidQuote } from './alpha-router';
+export declare class V4Route extends V4RouteRaw<Currency, Currency> {
+    protocol: Protocol.V4;
+}
+export declare class V3Route extends V3RouteRaw<Token, Token> {
+    protocol: Protocol.V3;
+}
+export declare class V2Route extends V2RouteRaw<Token, Token> {
+    protocol: Protocol.V2;
+}
+export declare class MixedRoute extends MixedRouteSDK<Currency, Currency> {
+    protocol: Protocol.MIXED;
+}
+export type SupportedRoutes = V4Route | V3Route | V2Route | MixedRoute;
+export type SwapRoute = {
+    /**
+     * The quote for the swap.
+     * For EXACT_IN swaps this will be an amount of token out.
+     * For EXACT_OUT this will be an amount of token in.
+     */
+    quote: CurrencyAmount;
+    /**
+     * The quote adjusted for the estimated gas used by the swap.
+     * This is computed by estimating the amount of gas used by the swap, converting
+     * this estimate to be in terms of the quote token, and subtracting that from the quote.
+     * i.e. quoteGasAdjusted = quote - estimatedGasUsedQuoteToken
+     */
+    quoteGasAdjusted: CurrencyAmount;
+    /**
+     * The quote adjusted for the estimated gas used by the swap as well as the portion amount, if applicable.
+     * This is computed by estimating the amount of gas used by the swap, converting
+     * this estimate to be in terms of the quote token, and subtracting that from the quote.
+     * Then it uses the IPortionProvider.getPortionAdjustedQuote method to adjust the quote for the portion amount.
+     * i.e. quoteGasAdjusted = quote - estimatedGasUsedQuoteToken - portionAmount
+     */
+    quoteGasAndPortionAdjusted?: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap.
+     */
+    estimatedGasUsed: BigNumber;
+    /**
+     * The estimate of the gas used by the swap in terms of the quote token.
+     */
+    estimatedGasUsedQuoteToken: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap in USD.
+     */
+    estimatedGasUsedUSD: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap in terms of the gas token if specified.
+     * will be undefined if no gas token is specified in the AlphaRouter config
+     */
+    estimatedGasUsedGasToken?: CurrencyAmount;
+    gasPriceWei: BigNumber;
+    /**
+     * The Trade object representing the swap.
+     */
+    trade: Trade<Currency, Currency, TradeType>;
+    /**
+     * The routes of the swap.
+     */
+    route: RouteWithValidQuote[];
+    /**
+     * The block number used when computing the swap.
+     */
+    blockNumber: BigNumber;
+    /**
+     * The calldata to execute the swap. Only returned if swapConfig was provided when calling the router.
+     */
+    methodParameters?: MethodParameters;
+    /**
+     * Enum that is returned if simulation was requested
+     * 0 if simulation was not supported
+     * 1 if simulation was attempted and failed
+     * 2 if simulation was successful (simulated gas estimates are returned)
+     * 3 ...
+     */
+    simulationStatus?: SimulationStatus;
+    /**
+     * Used internally within routing-api to see how many route requests
+     * hit the cached routes. This is used further down the line for future perf optimizations.
+     */
+    hitsCachedRoute?: boolean;
+    /**
+     * Portion amount either echoed from upstream routing-api for exact out or calculated from portionBips for exact in
+     */
+    portionAmount?: CurrencyAmount;
+};
+export type MethodParameters = SDKMethodParameters & {
+    to: string;
+};
+export type SwapToRatioRoute = SwapRoute & {
+    optimalRatio: Fraction;
+    postSwapTargetPool: Pool;
+};
+export declare enum SwapToRatioStatus {
+    SUCCESS = 1,
+    NO_ROUTE_FOUND = 2,
+    NO_SWAP_NEEDED = 3
+}
+export type SwapToRatioSuccess = {
+    status: SwapToRatioStatus.SUCCESS;
+    result: SwapToRatioRoute;
+};
+export type SwapToRatioFail = {
+    status: SwapToRatioStatus.NO_ROUTE_FOUND;
+    error: string;
+};
+export type SwapToRatioNoSwapNeeded = {
+    status: SwapToRatioStatus.NO_SWAP_NEEDED;
+};
+export type SwapToRatioResponse = SwapToRatioSuccess | SwapToRatioFail | SwapToRatioNoSwapNeeded;
+export declare enum SwapType {
+    UNIVERSAL_ROUTER = 0,
+    SWAP_ROUTER_02 = 1
+}
+export type SwapOptionsUniversalRouter = UniversalRouterSwapOptions & {
+    type: SwapType.UNIVERSAL_ROUTER;
+    version: UniversalRouterVersion;
+    simulate?: {
+        fromAddress: string;
+    };
+};
+export type SwapOptionsSwapRouter02 = {
+    type: SwapType.SWAP_ROUTER_02;
+    recipient: string;
+    slippageTolerance: Percent;
+    deadline: number;
+    simulate?: {
+        fromAddress: string;
+    };
+    inputTokenPermit?: {
+        v: 0 | 1 | 27 | 28;
+        r: string;
+        s: string;
+    } & ({
+        amount: string;
+        deadline: string;
+    } | {
+        nonce: string;
+        expiry: string;
+    });
+};
+export type SwapOptions = SwapOptionsUniversalRouter | SwapOptionsSwapRouter02;
+export type SwapAndAddConfig = {
+    maxIterations: number;
+    ratioErrorTolerance: Fraction;
+};
+export type SwapAndAddOptions = {
+    swapOptions: SwapOptionsSwapRouter02;
+    addLiquidityOptions: CondensedAddLiquidityOptions;
+};
+export type SwapAndAddParameters = {
+    initialBalanceTokenIn: CurrencyAmount;
+    initialBalanceTokenOut: CurrencyAmount;
+    preLiquidityPosition: Position;
+};
+/**
+ * Provides functionality for finding optimal swap routes on the Uniswap protocol.
+ *
+ * @export
+ * @abstract
+ * @class IRouter
+ */
+export declare abstract class IRouter<RoutingConfig> {
+    /**
+     * Finds the optimal way to swap tokens, and returns the route as well as a quote for the swap.
+     * Considers split routes, multi-hop swaps, and gas costs.
+     *
+     * @abstract
+     * @param amount The amount specified by the user. For EXACT_IN swaps, this is the input token amount. For EXACT_OUT swaps, this is the output token.
+     * @param quoteCurrency The currency of the token we are returning a quote for. For EXACT_IN swaps, this is the output token. For EXACT_OUT, this is the input token.
+     * @param tradeType The type of the trade, either exact in or exact out.
+     * @param [swapOptions] Optional config for executing the swap. If provided, calldata for executing the swap will also be returned.
+     * @param [partialRoutingConfig] Optional config for finding the optimal route.
+     * @returns The swap route.
+     */
+    abstract route(amount: CurrencyAmount, quoteCurrency: Currency, swapType: TradeType, swapOptions?: SwapOptions, partialRoutingConfig?: Partial<RoutingConfig>): Promise<SwapRoute | null>;
+}
+export declare abstract class ISwapToRatio<RoutingConfig, SwapAndAddConfig> {
+    abstract routeToRatio(token0Balance: CurrencyAmount, token1Balance: CurrencyAmount, position: Position, swapAndAddConfig: SwapAndAddConfig, swapAndAddOptions?: SwapAndAddOptions, routingConfig?: RoutingConfig): Promise<SwapToRatioResponse>;
+}
+export declare function cloneV2RouteWithNewPools(originalRoute: V2Route, newPools: Pair[]): V2Route;
+export declare function cloneV3RouteWithNewPools(originalRoute: V3Route, newPools: V3Pool[]): V3Route;
+export declare function cloneV4RouteWithNewPools(originalRoute: V4Route, newPools: V4Pool[]): V4Route;
+export declare function cloneMixedRouteWithNewPools(originalRoute: MixedRoute, newPools: TPool[]): MixedRoute;

package/build/module/routers/router.js

@@ -0,0 +1,79 @@
+import { MixedRouteSDK, Protocol, } from '@uniswap/router-sdk';
+import { Route as V2RouteRaw } from '@uniswap/v2-sdk';
+import { Route as V3RouteRaw, } from '@uniswap/v3-sdk';
+import { Route as V4RouteRaw } from '@uniswap/v4-sdk';
+export class V4Route extends V4RouteRaw {
+    constructor() {
+        super(...arguments);
+        this.protocol = Protocol.V4;
+    }
+}
+export class V3Route extends V3RouteRaw {
+    constructor() {
+        super(...arguments);
+        this.protocol = Protocol.V3;
+    }
+}
+export class V2Route extends V2RouteRaw {
+    constructor() {
+        super(...arguments);
+        this.protocol = Protocol.V2;
+    }
+}
+export class MixedRoute extends MixedRouteSDK {
+    constructor() {
+        super(...arguments);
+        this.protocol = Protocol.MIXED;
+    }
+}
+export var SwapToRatioStatus;
+(function (SwapToRatioStatus) {
+    SwapToRatioStatus[SwapToRatioStatus["SUCCESS"] = 1] = "SUCCESS";
+    SwapToRatioStatus[SwapToRatioStatus["NO_ROUTE_FOUND"] = 2] = "NO_ROUTE_FOUND";
+    SwapToRatioStatus[SwapToRatioStatus["NO_SWAP_NEEDED"] = 3] = "NO_SWAP_NEEDED";
+})(SwapToRatioStatus || (SwapToRatioStatus = {}));
+export var SwapType;
+(function (SwapType) {
+    SwapType[SwapType["UNIVERSAL_ROUTER"] = 0] = "UNIVERSAL_ROUTER";
+    SwapType[SwapType["SWAP_ROUTER_02"] = 1] = "SWAP_ROUTER_02";
+})(SwapType || (SwapType = {}));
+/**
+ * Provides functionality for finding optimal swap routes on the Uniswap protocol.
+ *
+ * @export
+ * @abstract
+ * @class IRouter
+ */
+export class IRouter {
+}
+export class ISwapToRatio {
+}
+export function cloneV2RouteWithNewPools(originalRoute, newPools) {
+    // Reuse the original input and output currencies
+    const input = originalRoute.input;
+    const output = originalRoute.output;
+    // Construct a new Route instance with the new pairs
+    return new V2Route(newPools, input, output);
+}
+export function cloneV3RouteWithNewPools(originalRoute, newPools) {
+    // Reuse the original input and output currencies
+    const input = originalRoute.input;
+    const output = originalRoute.output;
+    // Construct a new Route instance with the new pairs
+    return new V3Route(newPools, input, output);
+}
+export function cloneV4RouteWithNewPools(originalRoute, newPools) {
+    // Reuse the original input and output currencies
+    const input = originalRoute.input;
+    const output = originalRoute.output;
+    // Construct a new Route instance with the new pairs
+    return new V4Route(newPools, input, output);
+}
+export function cloneMixedRouteWithNewPools(originalRoute, newPools) {
+    // Reuse the original input and output currencies
+    const input = originalRoute.input;
+    const output = originalRoute.output;
+    // Construct a new Route instance with the new pairs
+    return new MixedRoute(newPools, input, output, /* retainFakePools = */ true);
+}
+//# sourceMappingURL=data:application/json;base64,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