@kumbaya_xyz/smart-order-router 4.22.38

package/build/module/routers/alpha-router/quoters/v3-quoter.js

@@ -0,0 +1,118 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { TradeType } from '@uniswap/sdk-core';
+import _ from 'lodash';
+import { TokenValidationResult, } from '../../../providers';
+import { log, metric, MetricLoggerUnit, routeToString, } from '../../../util';
+import { V3RouteWithValidQuote } from '../entities';
+import { computeAllV3Routes } from '../functions/compute-all-routes';
+import { BaseQuoter } from './base-quoter';
+export class V3Quoter extends BaseQuoter {
+    constructor(v3SubgraphProvider, v3PoolProvider, onChainQuoteProvider, tokenProvider, chainId, blockedTokenListProvider, tokenValidatorProvider) {
+        super(tokenProvider, chainId, Protocol.V3, blockedTokenListProvider, tokenValidatorProvider);
+        this.v3SubgraphProvider = v3SubgraphProvider;
+        this.v3PoolProvider = v3PoolProvider;
+        this.onChainQuoteProvider = onChainQuoteProvider;
+    }
+    async getRoutes(tokenIn, tokenOut, v3CandidatePools, _tradeType, routingConfig) {
+        const beforeGetRoutes = Date.now();
+        // Fetch all the pools that we will consider routing via. There are thousands
+        // of pools, so we filter them to a set of candidate pools that we expect will
+        // result in good prices.
+        const { poolAccessor, candidatePools } = v3CandidatePools;
+        const poolsRaw = poolAccessor.getAllPools();
+        // Drop any pools that contain fee on transfer tokens (not supported by v3) or have issues with being transferred.
+        const pools = await this.applyTokenValidatorToPools(poolsRaw, (token, tokenValidation) => {
+            // If there is no available validation result we assume the token is fine.
+            if (!tokenValidation) {
+                return false;
+            }
+            // Only filters out *intermediate* pools that involve tokens that we detect
+            // cant be transferred. This prevents us trying to route through tokens that may
+            // not be transferrable, but allows users to still swap those tokens if they
+            // specify.
+            //
+            if (tokenValidation == TokenValidationResult.STF &&
+                (token.equals(tokenIn) || token.equals(tokenOut))) {
+                return false;
+            }
+            // ROUTE-495 - bypass v3 pool FOT check for $ELMO token
+            if (tokenValidation == TokenValidationResult.FOT &&
+                token.wrapped.address.toLowerCase() ===
+                    '0x335f4e66b9b61cee5ceade4e727fcec20156b2f0' &&
+                (token.equals(tokenIn) || token.equals(tokenOut))) {
+                return false;
+            }
+            return (tokenValidation == TokenValidationResult.FOT ||
+                tokenValidation == TokenValidationResult.STF);
+        });
+        // Given all our candidate pools, compute all the possible ways to route from tokenIn to tokenOut.
+        const { maxSwapsPerPath } = routingConfig;
+        const routes = computeAllV3Routes(tokenIn, tokenOut, pools, maxSwapsPerPath);
+        metric.putMetric('V3GetRoutesLoad', Date.now() - beforeGetRoutes, MetricLoggerUnit.Milliseconds);
+        metric.putMetric(`V3GetRoutesLoad_Chain${this.chainId}`, Date.now() - beforeGetRoutes, MetricLoggerUnit.Milliseconds);
+        return {
+            routes,
+            candidatePools,
+        };
+    }
+    async getQuotes(routes, amounts, percents, quoteToken, tradeType, routingConfig, candidatePools, gasModel) {
+        const beforeGetQuotes = Date.now();
+        log.info('Starting to get V3 quotes');
+        if (gasModel === undefined) {
+            throw new Error('GasModel for V3RouteWithValidQuote is required to getQuotes');
+        }
+        if (routes.length == 0) {
+            return { routesWithValidQuotes: [], candidatePools };
+        }
+        // For all our routes, and all the fractional amounts, fetch quotes on-chain.
+        const quoteFn = tradeType == TradeType.EXACT_INPUT
+            ? this.onChainQuoteProvider.getQuotesManyExactIn.bind(this.onChainQuoteProvider)
+            : this.onChainQuoteProvider.getQuotesManyExactOut.bind(this.onChainQuoteProvider);
+        const beforeQuotes = Date.now();
+        log.info(`Getting quotes for V3 for ${routes.length} routes with ${amounts.length} amounts per route.`);
+        const { routesWithQuotes } = await quoteFn(amounts, routes, routingConfig);
+        metric.putMetric('V3QuotesLoad', Date.now() - beforeQuotes, MetricLoggerUnit.Milliseconds);
+        metric.putMetric('V3QuotesFetched', _(routesWithQuotes)
+            .map(([, quotes]) => quotes.length)
+            .sum(), MetricLoggerUnit.Count);
+        const routesWithValidQuotes = [];
+        for (const routeWithQuote of routesWithQuotes) {
+            const [route, quotes] = routeWithQuote;
+            for (let i = 0; i < quotes.length; i++) {
+                const percent = percents[i];
+                const amountQuote = quotes[i];
+                const { quote, amount, sqrtPriceX96AfterList, initializedTicksCrossedList, gasEstimate, } = amountQuote;
+                if (!quote ||
+                    !sqrtPriceX96AfterList ||
+                    !initializedTicksCrossedList ||
+                    !gasEstimate) {
+                    log.debug({
+                        route: routeToString(route),
+                        amountQuote,
+                    }, 'Dropping a null V3 quote for route.');
+                    continue;
+                }
+                const routeWithValidQuote = new V3RouteWithValidQuote({
+                    route,
+                    rawQuote: quote,
+                    amount,
+                    percent,
+                    sqrtPriceX96AfterList,
+                    initializedTicksCrossedList,
+                    quoterGasEstimate: gasEstimate,
+                    gasModel,
+                    quoteToken,
+                    tradeType,
+                    v3PoolProvider: this.v3PoolProvider,
+                });
+                routesWithValidQuotes.push(routeWithValidQuote);
+            }
+        }
+        metric.putMetric('V3GetQuotesLoad', Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+        return {
+            routesWithValidQuotes,
+            candidatePools,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/routers/alpha-router/quoters/v4-quoter.d.ts

@@ -0,0 +1,18 @@
+import { ChainId, Currency, TradeType } from '@uniswap/sdk-core';
+import { IOnChainQuoteProvider, ITokenListProvider, ITokenProvider, ITokenValidatorProvider, IV4PoolProvider, IV4SubgraphProvider } from '../../../providers';
+import { CurrencyAmount } from '../../../util';
+import { V4Route } from '../../router';
+import { AlphaRouterConfig } from '../alpha-router';
+import { RouteWithValidQuote } from '../entities';
+import { CandidatePoolsBySelectionCriteria, V4CandidatePools } from '../functions/get-candidate-pools';
+import { IGasModel } from '../gas-models';
+import { BaseQuoter } from './base-quoter';
+import { GetQuotesResult, GetRoutesResult } from './model';
+export declare class V4Quoter extends BaseQuoter<V4CandidatePools, V4Route, Currency> {
+    protected v4SubgraphProvider: IV4SubgraphProvider;
+    protected v4PoolProvider: IV4PoolProvider;
+    protected onChainQuoteProvider: IOnChainQuoteProvider;
+    constructor(v4SubgraphProvider: IV4SubgraphProvider, v4PoolProvider: IV4PoolProvider, onChainQuoteProvider: IOnChainQuoteProvider, tokenProvider: ITokenProvider, chainId: ChainId, blockedTokenListProvider?: ITokenListProvider, tokenValidatorProvider?: ITokenValidatorProvider);
+    protected getRoutes(currencyIn: Currency, currencyOut: Currency, v4CandidatePools: V4CandidatePools, _tradeType: TradeType, routingConfig: AlphaRouterConfig): Promise<GetRoutesResult<V4Route>>;
+    getQuotes(routes: V4Route[], amounts: CurrencyAmount[], percents: number[], quoteCurrency: Currency, tradeType: TradeType, routingConfig: AlphaRouterConfig, candidatePools?: CandidatePoolsBySelectionCriteria, gasModel?: IGasModel<RouteWithValidQuote>): Promise<GetQuotesResult>;
+}

package/build/module/routers/alpha-router/quoters/v4-quoter.js

@@ -0,0 +1,115 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { TradeType } from '@uniswap/sdk-core';
+import _ from 'lodash';
+import { TokenValidationResult, } from '../../../providers';
+import { log, metric, MetricLoggerUnit, routeToString, } from '../../../util';
+import { V4RouteWithValidQuote } from '../entities';
+import { computeAllV4Routes } from '../functions/compute-all-routes';
+import { BaseQuoter } from './base-quoter';
+export class V4Quoter extends BaseQuoter {
+    constructor(v4SubgraphProvider, v4PoolProvider, onChainQuoteProvider, tokenProvider, chainId, blockedTokenListProvider, tokenValidatorProvider) {
+        super(tokenProvider, chainId, Protocol.V4, blockedTokenListProvider, tokenValidatorProvider);
+        this.v4SubgraphProvider = v4SubgraphProvider;
+        this.v4PoolProvider = v4PoolProvider;
+        this.onChainQuoteProvider = onChainQuoteProvider;
+    }
+    async getRoutes(currencyIn, currencyOut, v4CandidatePools, _tradeType, routingConfig) {
+        const beforeGetRoutes = Date.now();
+        // Fetch all the pools that we will consider routing via. There are thousands
+        // of pools, so we filter them to a set of candidate pools that we expect will
+        // result in good prices.
+        const { poolAccessor, candidatePools } = v4CandidatePools;
+        const poolsRaw = poolAccessor.getAllPools();
+        const manuallyRoutedPools = poolsRaw.filter((pool) => { var _a; return (_a = routingConfig.poolsToManuallyRouteThrough) === null || _a === void 0 ? void 0 : _a.includes(pool.poolId); });
+        // Drop any pools that contain fee on transfer tokens (not supported by v4) or have issues with being transferred.
+        const pools = await this.applyTokenValidatorToPools([...poolsRaw, ...manuallyRoutedPools], (token, tokenValidation) => {
+            // If there is no available validation result we assume the token is fine.
+            if (!tokenValidation) {
+                return false;
+            }
+            // Only filters out *intermediate* pools that involve tokens that we detect
+            // cant be transferred. This prevents us trying to route through tokens that may
+            // not be transferrable, but allows users to still swap those tokens if they
+            // specify.
+            //
+            if (tokenValidation == TokenValidationResult.STF &&
+                (token.equals(currencyIn) || token.equals(currencyOut))) {
+                return false;
+            }
+            return (tokenValidation == TokenValidationResult.FOT ||
+                tokenValidation == TokenValidationResult.STF);
+        });
+        // Given all our candidate pools, compute all the possible ways to route from currencyIn to tokenOut.
+        const { maxSwapsPerPath } = routingConfig;
+        const routes = computeAllV4Routes(currencyIn, currencyOut, pools, maxSwapsPerPath, routingConfig.hooksOptions);
+        metric.putMetric('V4GetRoutesLoad', Date.now() - beforeGetRoutes, MetricLoggerUnit.Milliseconds);
+        metric.putMetric(`V4GetRoutesLoad_Chain${this.chainId}`, Date.now() - beforeGetRoutes, MetricLoggerUnit.Milliseconds);
+        return {
+            routes,
+            candidatePools,
+        };
+    }
+    async getQuotes(routes, amounts, percents, quoteCurrency, tradeType, routingConfig, candidatePools, gasModel) {
+        const beforeGetQuotes = Date.now();
+        log.info('Starting to get V4 quotes');
+        if (gasModel === undefined) {
+            throw new Error('GasModel for V4RouteWithValidQuote is required to getQuotes');
+        }
+        if (routes.length == 0) {
+            return { routesWithValidQuotes: [], candidatePools };
+        }
+        // For all our routes, and all the fractional amounts, fetch quotes on-chain.
+        const quoteFn = tradeType == TradeType.EXACT_INPUT
+            ? this.onChainQuoteProvider.getQuotesManyExactIn.bind(this.onChainQuoteProvider)
+            : this.onChainQuoteProvider.getQuotesManyExactOut.bind(this.onChainQuoteProvider);
+        const beforeQuotes = Date.now();
+        log.info(`Getting quotes for V4 for ${routes.length} routes with ${amounts.length} amounts per route.`);
+        const { routesWithQuotes } = await quoteFn(amounts, routes, routingConfig);
+        metric.putMetric('V4QuotesLoad', Date.now() - beforeQuotes, MetricLoggerUnit.Milliseconds);
+        metric.putMetric('V4QuotesFetched', _(routesWithQuotes)
+            .map(([, quotes]) => quotes.length)
+            .sum(), MetricLoggerUnit.Count);
+        const routesWithValidQuotes = [];
+        for (const routeWithQuote of routesWithQuotes) {
+            const [route, quotes] = routeWithQuote;
+            for (let i = 0; i < quotes.length; i++) {
+                const percent = percents[i];
+                const amountQuote = quotes[i];
+                const { quote, amount, sqrtPriceX96AfterList, initializedTicksCrossedList, gasEstimate, } = amountQuote;
+                if (!quote ||
+                    !sqrtPriceX96AfterList ||
+                    !initializedTicksCrossedList ||
+                    !gasEstimate) {
+                    log.debug({
+                        route: routeToString(route),
+                        amountQuote,
+                    }, 'Dropping a null V4 quote for route.');
+                    continue;
+                }
+                const routeWithValidQuote = new V4RouteWithValidQuote({
+                    route,
+                    rawQuote: quote,
+                    amount,
+                    percent,
+                    sqrtPriceX96AfterList,
+                    initializedTicksCrossedList,
+                    quoterGasEstimate: gasEstimate,
+                    gasModel,
+                    // TODO: ROUTE-306 make it unwrapped, once v4 gas model supports native quote currency
+                    // For now it's ok to keep it wrapped,
+                    // because the quote is the fairly accurate quote from the native currency routing
+                    quoteToken: quoteCurrency.wrapped,
+                    tradeType,
+                    v4PoolProvider: this.v4PoolProvider,
+                });
+                routesWithValidQuotes.push(routeWithValidQuote);
+            }
+        }
+        metric.putMetric('V4GetQuotesLoad', Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+        return {
+            routesWithValidQuotes,
+            candidatePools,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+export * from '../util/metric';
+export * from './alpha-router';
+export * from './legacy-router';
+export * from './router';

package/build/module/routers/index.js

@@ -0,0 +1,5 @@
+export * from '../util/metric';
+export * from './alpha-router';
+export * from './legacy-router';
+export * from './router';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcm91dGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFVBQVUsQ0FBQyJ9

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

@@ -0,0 +1,213 @@
+import { ChainId, Token } from '@uniswap/sdk-core';
+import { ITokenProvider } from '../../providers/token-provider';
+type ChainTokenList = {
+    readonly [chainId in ChainId]: Token[];
+};
+export declare const BASES_TO_CHECK_TRADES_AGAINST: (_tokenProvider: ITokenProvider) => ChainTokenList;
+export declare const ADDITIONAL_BASES: (tokenProvider: ITokenProvider) => Promise<{
+    1?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    5?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    11155111?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    10?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    420?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    11155420?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    42161?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    421613?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    421614?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    137?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    80001?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    42220?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    44787?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    100?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1284?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    56?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    43114?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    84531?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    84532?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    8453?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    7777777?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    999999999?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    30?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    81457?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    324?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    480?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1301?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    130?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    10143?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1868?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    143?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    196?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    6343?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+}>;
+/**
+ * Some tokens can only be swapped via certain pairs, so we override the list of bases that are considered for these
+ * tokens.
+ */
+export declare const CUSTOM_BASES: (tokenProvider: ITokenProvider) => Promise<{
+    1?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    5?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    11155111?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    10?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    420?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    11155420?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    42161?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    421613?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    421614?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    137?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    80001?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    42220?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    44787?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    100?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1284?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    56?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    43114?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    84531?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    84532?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    8453?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    7777777?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    999999999?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    30?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    81457?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    324?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    480?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1301?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    130?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    10143?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    1868?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    143?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    196?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+    6343?: {
+        [tokenAddress: string]: Token[];
+    } | undefined;
+}>;
+export {};

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

@@ -0,0 +1,130 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ChainId } from '@uniswap/sdk-core';
+import { BTC_BNB, BUSD_BNB, DAI_AVAX, DAI_BNB, DAI_MAINNET, DAI_UNICHAIN, USDB_BLAST, USDC_AVAX, USDC_BASE, USDC_BASE_SEPOLIA, USDC_BNB, USDC_MAINNET, USDC_MEGAETH_TESTNET, USDC_MONAD, USDC_SONEIUM, USDC_UNICHAIN, USDC_UNICHAIN_SEPOLIA, USDC_WORLDCHAIN, USDC_ZKSYNC, USDCE_ZKSYNC, USDT_BNB, USDT_MAINNET, USDT_MONAD_TESTNET, WBTC_MAINNET, WBTC_WORLDCHAIN, WLD_WORLDCHAIN, WMATIC_POLYGON, WMATIC_POLYGON_MUMBAI, } from '../../providers/token-provider';
+import { WRAPPED_NATIVE_CURRENCY } from '../../util/chains';
+export const BASES_TO_CHECK_TRADES_AGAINST = (_tokenProvider) => {
+    return {
+        [ChainId.MAINNET]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.MAINNET],
+            DAI_MAINNET,
+            USDC_MAINNET,
+            USDT_MAINNET,
+            WBTC_MAINNET,
+        ],
+        [ChainId.GOERLI]: [WRAPPED_NATIVE_CURRENCY[ChainId.GOERLI]],
+        [ChainId.SEPOLIA]: [WRAPPED_NATIVE_CURRENCY[ChainId.SEPOLIA]],
+        [ChainId.OPTIMISM]: [WRAPPED_NATIVE_CURRENCY[ChainId.OPTIMISM]],
+        [ChainId.OPTIMISM_GOERLI]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.OPTIMISM_GOERLI],
+        ],
+        [ChainId.OPTIMISM_SEPOLIA]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.OPTIMISM_SEPOLIA],
+        ],
+        [ChainId.ARBITRUM_ONE]: [WRAPPED_NATIVE_CURRENCY[ChainId.ARBITRUM_ONE]],
+        [ChainId.ARBITRUM_GOERLI]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.ARBITRUM_GOERLI],
+        ],
+        [ChainId.ARBITRUM_SEPOLIA]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.ARBITRUM_SEPOLIA],
+        ],
+        [ChainId.POLYGON]: [WMATIC_POLYGON],
+        [ChainId.POLYGON_MUMBAI]: [WMATIC_POLYGON_MUMBAI],
+        [ChainId.CELO]: [WRAPPED_NATIVE_CURRENCY[ChainId.CELO]],
+        [ChainId.CELO_ALFAJORES]: [WRAPPED_NATIVE_CURRENCY[ChainId.CELO_ALFAJORES]],
+        [ChainId.GNOSIS]: [WRAPPED_NATIVE_CURRENCY[ChainId.GNOSIS]],
+        [ChainId.MOONBEAM]: [WRAPPED_NATIVE_CURRENCY[ChainId.MOONBEAM]],
+        [ChainId.BNB]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.BNB],
+            BUSD_BNB,
+            DAI_BNB,
+            USDC_BNB,
+            USDT_BNB,
+            BTC_BNB,
+        ],
+        [ChainId.AVALANCHE]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.AVALANCHE],
+            USDC_AVAX,
+            DAI_AVAX,
+        ],
+        [ChainId.BASE]: [WRAPPED_NATIVE_CURRENCY[ChainId.BASE], USDC_BASE],
+        [ChainId.BASE_GOERLI]: [WRAPPED_NATIVE_CURRENCY[ChainId.BASE_GOERLI]],
+        [ChainId.ZORA]: [WRAPPED_NATIVE_CURRENCY[ChainId.ZORA]],
+        [ChainId.ZORA_SEPOLIA]: [WRAPPED_NATIVE_CURRENCY[ChainId.ZORA_SEPOLIA]],
+        [ChainId.ROOTSTOCK]: [WRAPPED_NATIVE_CURRENCY[ChainId.ROOTSTOCK]],
+        [ChainId.BLAST]: [WRAPPED_NATIVE_CURRENCY[ChainId.BLAST], USDB_BLAST],
+        [ChainId.ZKSYNC]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.ZKSYNC],
+            USDCE_ZKSYNC,
+            USDC_ZKSYNC,
+        ],
+        [ChainId.WORLDCHAIN]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.WORLDCHAIN],
+            USDC_WORLDCHAIN,
+            WLD_WORLDCHAIN,
+            WBTC_WORLDCHAIN,
+        ],
+        [ChainId.UNICHAIN_SEPOLIA]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.UNICHAIN_SEPOLIA],
+            USDC_UNICHAIN_SEPOLIA,
+        ],
+        [ChainId.UNICHAIN]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.UNICHAIN],
+            DAI_UNICHAIN,
+            USDC_UNICHAIN,
+        ],
+        [ChainId.MONAD_TESTNET]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.MONAD_TESTNET],
+            USDT_MONAD_TESTNET,
+        ],
+        [ChainId.MONAD]: [WRAPPED_NATIVE_CURRENCY[ChainId.MONAD], USDC_MONAD],
+        [ChainId.BASE_SEPOLIA]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.BASE_SEPOLIA],
+            USDC_BASE_SEPOLIA,
+        ],
+        [ChainId.SONEIUM]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.SONEIUM],
+            USDC_SONEIUM,
+        ],
+        [ChainId.MEGAETH_TESTNET]: [
+            WRAPPED_NATIVE_CURRENCY[ChainId.MEGAETH_TESTNET],
+            USDC_MEGAETH_TESTNET,
+        ],
+        [ChainId.XLAYER]: [WRAPPED_NATIVE_CURRENCY[ChainId.XLAYER]],
+    };
+};
+const getBasePairByAddress = async (tokenProvider, _chainId, fromAddress, toAddress) => {
+    const accessor = await tokenProvider.getTokens([toAddress]);
+    const toToken = accessor.getTokenByAddress(toAddress);
+    if (!toToken)
+        return {};
+    return {
+        [fromAddress]: [toToken],
+    };
+};
+export const ADDITIONAL_BASES = async (tokenProvider) => {
+    return {
+        [ChainId.MAINNET]: {
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0xA948E86885e12Fb09AfEF8C52142EBDbDf73cD18', '0x1f9840a85d5af5bf1d1762f925bdaddc4201f984')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0x561a4717537ff4AF5c687328c0f7E90a319705C0', '0x1f9840a85d5af5bf1d1762f925bdaddc4201f984')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0x956F47F50A910163D8BF957Cf5846D573E7f87CA', '0xc7283b66Eb1EB5FB86327f08e1B5816b0720212B')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0xc7283b66Eb1EB5FB86327f08e1B5816b0720212B', '0x956F47F50A910163D8BF957Cf5846D573E7f87CA')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0x853d955acef822db058eb8505911ed77f175b99e', '0x3432b6a60d23ca0dfca7761b7ab56459d9c964d0')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0x3432b6a60d23ca0dfca7761b7ab56459d9c964d0', '0x853d955acef822db058eb8505911ed77f175b99e')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599', '0xeb4c2781e4eba804ce9a9803c67d0893436bb27d')),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0xeb4c2781e4eba804ce9a9803c67d0893436bb27d', '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599')),
+        },
+    };
+};
+/**
+ * Some tokens can only be swapped via certain pairs, so we override the list of bases that are considered for these
+ * tokens.
+ */
+export const CUSTOM_BASES = async (tokenProvider) => {
+    return {
+        [ChainId.MAINNET]: {
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0xd46ba6d942050d489dbd938a2c909a5d5039a161', DAI_MAINNET.address)),
+            ...(await getBasePairByAddress(tokenProvider, ChainId.MAINNET, '0xd46ba6d942050d489dbd938a2c909a5d5039a161', WRAPPED_NATIVE_CURRENCY[1].address)),
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+export * from './legacy-router';

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

@@ -0,0 +1,2 @@
+export * from './legacy-router';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcm91dGVycy9sZWdhY3ktcm91dGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMifQ==