@ring-protocol/smart-order-router 0.5.0

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

@@ -0,0 +1,14 @@
+import { Fraction } from '@ring-protocol/sdk-core';
+import { CurrencyAmount } from '../../../util/amounts';
+export function calculateRatioAmountIn(optimalRatio, inputTokenPrice, inputBalance, outputBalance) {
+    // formula: amountToSwap = (inputBalance - (optimalRatio * outputBalance)) / ((optimalRatio * inputTokenPrice) + 1))
+    const amountToSwapRaw = new 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 CurrencyAmount.fromRawAmount(inputBalance.currency, amountToSwapRaw.quotient);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yb3V0ZXJzL2FscGhhLXJvdXRlci9mdW5jdGlvbnMvY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFbkQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXZELE1BQU0sVUFBVSxzQkFBc0IsQ0FDcEMsWUFBc0IsRUFDdEIsZUFBeUIsRUFDekIsWUFBNEIsRUFDNUIsYUFBNkI7SUFFN0Isb0hBQW9IO0lBQ3BILE1BQU0sZUFBZSxHQUFHLElBQUksUUFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUM7U0FDeEQsUUFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1NBQ3ZELE1BQU0sQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXpELElBQUksZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsRUFBRTtRQUMvQiwyREFBMkQ7UUFDM0QsTUFBTSxJQUFJLEtBQUssQ0FBQywrQ0FBK0MsQ0FBQyxDQUFDO0tBQ2xFO0lBRUQsT0FBTyxjQUFjLENBQUMsYUFBYSxDQUNqQyxZQUFZLENBQUMsUUFBUSxFQUNyQixlQUFlLENBQUMsUUFBUSxDQUN6QixDQUFDO0FBQ0osQ0FBQyJ9

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

@@ -0,0 +1,16 @@
+import { TPool } from '@ring-protocol/router-sdk';
+import { Currency, Token } from '@ring-protocol/sdk-core';
+import { Pair } from '@ring-protocol/v2-sdk';
+import { Pool as V3Pool } from '@ring-protocol/v3-sdk';
+import { Pool as V4Pool } from '@ring-protocol/v4-sdk';
+import { Pair as RingFewV2Pair } from '@ring-protocol/few-v2-sdk';
+import { HooksOptions } from '../../../util/hooksOptions';
+import { MixedRoute, SupportedRoutes, RingFewV2Route, V2Route, V3Route, V4Route } from '../../router';
+export declare function computeAllV4Routes(currencyIn: Currency, currencyOut: Currency, pools: V4Pool[], maxHops: number, hooksOptions?: HooksOptions): V4Route[];
+export declare function computeAllUniswapFewV4Routes(currencyIn: Currency, currencyOut: Currency, pools: V4Pool[], maxHops: number, hooksOptions?: HooksOptions): V4Route[];
+export declare function computeAllV3Routes(tokenIn: Token, tokenOut: Token, pools: V3Pool[], maxHops: number): V3Route[];
+export declare function computeAllUniswapFewV3Routes(tokenIn: Token, tokenOut: Token, pools: V3Pool[], maxHops: number): V3Route[];
+export declare function computeAllV2Routes(tokenIn: Token, tokenOut: Token, pools: Pair[], maxHops: number): V2Route[];
+export declare function computeAllRingFewV2Routes(tokenIn: Token, tokenOut: Token, pools: RingFewV2Pair[], maxHops: number): RingFewV2Route[];
+export declare function computeAllMixedRoutes(currencyIn: Currency, currencyOut: Currency, parts: TPool[], maxHops: number, shouldEnableMixedRouteEthWeth?: boolean, hooksOptions?: HooksOptions): MixedRoute[];
+export declare function computeAllRoutes<TypePool extends TPool, TRoute extends SupportedRoutes, TCurrency extends Currency>(tokenIn: TCurrency, tokenOut: TCurrency, buildRoute: (route: TypePool[], tokenIn: TCurrency, tokenOut: TCurrency) => TRoute, involvesToken: (pool: TypePool, token: TCurrency) => boolean, pools: TypePool[], maxHops: number): TRoute[];

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

@@ -0,0 +1,147 @@
+import { ADDRESS_ZERO } from '@ring-protocol/router-sdk';
+import { Pair } from '@ring-protocol/v2-sdk';
+import { Pool as V3Pool } from '@ring-protocol/v3-sdk';
+import { Pool as V4Pool } from '@ring-protocol/v4-sdk';
+import { getAddressLowerCase, nativeOnChain, V4_ETH_WETH_FAKE_POOL, } from '../../../util';
+import { HooksOptions } from '../../../util/hooksOptions';
+import { log } from '../../../util/log';
+import { poolToString, routeToString } from '../../../util/routes';
+import { MixedRoute, RingFewV2Route, V2Route, V3Route, V4Route, } from '../../router';
+export function computeAllV4Routes(currencyIn, currencyOut, pools, maxHops, hooksOptions) {
+    let filteredPools = pools;
+    if (hooksOptions === HooksOptions.HOOKS_ONLY) {
+        filteredPools = pools.filter((pool) => pool.hooks !== ADDRESS_ZERO);
+    }
+    if (hooksOptions === HooksOptions.NO_HOOKS) {
+        filteredPools = pools.filter((pool) => pool.hooks === ADDRESS_ZERO);
+    }
+    return computeAllRoutes(currencyIn, currencyOut, (route, currencyIn, currencyOut) => {
+        return new V4Route(route, currencyIn, currencyOut);
+    }, (pool, currency) => pool.involvesToken(currency), filteredPools, maxHops);
+}
+export function computeAllUniswapFewV4Routes(currencyIn, currencyOut, pools, maxHops, hooksOptions) {
+    let filteredPools = pools;
+    if (hooksOptions === HooksOptions.HOOKS_ONLY) {
+        filteredPools = pools.filter((pool) => pool.hooks !== ADDRESS_ZERO);
+    }
+    if (hooksOptions === HooksOptions.NO_HOOKS) {
+        filteredPools = pools.filter((pool) => pool.hooks === ADDRESS_ZERO);
+    }
+    return computeAllRoutes(currencyIn, currencyOut, (route, currencyIn, currencyOut) => {
+        return new V4Route(route, currencyIn, currencyOut);
+    }, (pool, currency) => pool.involvesToken(currency), filteredPools, maxHops);
+}
+export function computeAllV3Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new V3Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+export function computeAllUniswapFewV3Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new V3Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+export function computeAllV2Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new V2Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+export function computeAllRingFewV2Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new RingFewV2Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+export function computeAllMixedRoutes(currencyIn, currencyOut, parts, maxHops, shouldEnableMixedRouteEthWeth, hooksOptions) {
+    // first we need to filter non v4-pools
+    const filteredPools = !hooksOptions || hooksOptions === HooksOptions.HOOKS_INCLUSIVE
+        ? parts
+        : parts.filter((pool) => !(pool instanceof V4Pool));
+    if (hooksOptions === HooksOptions.HOOKS_ONLY) {
+        // we need to filter out v4-pools with hooks
+        // then concat the v4-pools with hooks
+        const v4HookslessPools = parts.filter((pool) => pool instanceof V4Pool && pool.hooks !== ADDRESS_ZERO);
+        parts = filteredPools.concat(v4HookslessPools);
+    }
+    if (hooksOptions === HooksOptions.NO_HOOKS) {
+        // we need to filter out v4-pools without hooks
+        // then concat the v4-pools without hooks
+        const v4HookfulPools = parts.filter((pool) => pool instanceof V4Pool && pool.hooks === ADDRESS_ZERO);
+        parts = filteredPools.concat(v4HookfulPools);
+    }
+    // only add fake v4 pool, if we see there's a native v4 pool in the candidate pool
+    const containsV4NativePools = parts.filter((pool) => pool instanceof V4Pool &&
+        pool.v4InvolvesToken(nativeOnChain(currencyIn.chainId))).length > 0;
+    const amendedPools = containsV4NativePools && shouldEnableMixedRouteEthWeth
+        ? parts.concat(V4_ETH_WETH_FAKE_POOL[currencyIn.chainId])
+        : parts;
+    // NOTE: we added a fake v4 pool, in order for mixed route to connect the v3 weth pool with v4 eth pool
+    const routesRaw = computeAllRoutes(currencyIn, currencyOut, (route, currencyIn, currencyOut) => {
+        // we only retake the fake v4 pool if the route contains a native v4 pool
+        return new MixedRoute(route, currencyIn, currencyOut, containsV4NativePools);
+    }, (pool, currency) => currency.isNative
+        ? pool.involvesToken(currency)
+        : pool.involvesToken(currency), amendedPools, maxHops);
+    /// filter out pure v4 and v3 and v2 routes
+    return routesRaw.filter((route) => {
+        return (!route.pools.every((pool) => pool instanceof V4Pool) &&
+            !route.pools.every((pool) => pool instanceof V3Pool) &&
+            !route.pools.every((pool) => pool instanceof Pair));
+    });
+}
+export function computeAllRoutes(tokenIn, tokenOut, buildRoute, involvesToken, pools, maxHops) {
+    var _a;
+    const poolsUsed = Array(pools.length).fill(false);
+    const routes = [];
+    const computeRoutes = (tokenIn, tokenOut, currentRoute, poolsUsed, tokensVisited, _previousTokenOut) => {
+        const currentRouteContainsFakeV4Pool = currentRoute.filter((pool) => pool instanceof V4Pool &&
+            pool.tickSpacing ===
+                V4_ETH_WETH_FAKE_POOL[tokenIn.chainId].tickSpacing).length > 0;
+        const amendedMaxHops = currentRouteContainsFakeV4Pool
+            ? maxHops + 1
+            : maxHops;
+        // amendedMaxHops is the maxHops + 1 if the current route contains a fake v4 pool
+        // b/c we want to allow the route to go through the fake v4 pool
+        // also gas wise, if a route goes through the fake v4 pool, mixed quoter will add the wrap/unwrap gas cost:
+        // https://github.com/Uniswap/mixed-quoter/pull/41/files#diff-a4d1289f264d1da22aac20cc55a9d01c8ba9cccd76ce1af8f952ec9034e7e1aaR189
+        // and SOR will use the gas cost from the mixed quoter:
+        // https://github.com/Uniswap/smart-order-router/blob/17da523f1af050e6430afb866d96681346c8fb8b/src/routers/alpha-router/gas-models/mixedRoute/mixed-route-heuristic-gas-model.ts#L222
+        if (currentRoute.length > amendedMaxHops) {
+            return;
+        }
+        if (currentRoute.length > 0 &&
+            involvesToken(currentRoute[currentRoute.length - 1], 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 (!involvesToken(curPool, previousTokenOut)) {
+                continue;
+            }
+            const currentTokenOut = curPool.token0.equals(previousTokenOut)
+                ? curPool.token1
+                : curPool.token0;
+            if (tokensVisited.has(getAddressLowerCase(currentTokenOut))) {
+                continue;
+            }
+            tokensVisited.add(getAddressLowerCase(currentTokenOut));
+            currentRoute.push(curPool);
+            poolsUsed[i] = true;
+            computeRoutes(tokenIn, tokenOut, currentRoute, poolsUsed, tokensVisited, currentTokenOut);
+            poolsUsed[i] = false;
+            currentRoute.pop();
+            tokensVisited.delete(getAddressLowerCase(currentTokenOut));
+        }
+    };
+    computeRoutes(tokenIn, tokenOut, [], poolsUsed, new Set([getAddressLowerCase(tokenIn)]));
+    log.info({
+        routes: routes.map(routeToString),
+        pools: pools.map(poolToString),
+    }, `Computed ${routes.length} possible routes for type ${(_a = routes[0]) === null || _a === void 0 ? void 0 : _a.protocol}.`);
+    return routes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute-all-routes.js","sourceRoot":"","sources":["../../../../../src/routers/alpha-router/functions/compute-all-routes.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,192 @@
+import { Protocol } from '@ring-protocol/router-sdk';
+import { ChainId, Currency, Token, TradeType } from '@ring-protocol/sdk-core';
+import { ITokenListProvider, IV2SubgraphProvider, IV4PoolProvider, IV4SubgraphProvider, V2SubgraphPool, RingV2SubgraphPool, V4PoolAccessor, V4SubgraphPool, IRingV2SubgraphProvider } 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 { IRingV2PoolProvider, RingFewV2PoolAccessor } from '../../../providers/fewV2/ring-pool-provider';
+import { AlphaRouterConfig } from '../alpha-router';
+export declare type SubgraphPool = V2SubgraphPool | V3SubgraphPool | V4SubgraphPool;
+export declare type CandidatePoolsBySelectionCriteria = {
+    protocol: Protocol;
+    selections: CandidatePoolsSelections;
+};
+export declare type SupportedCandidatePools = RingFewV2CandidatePools | V2CandidatePools | V3CandidatePools | V4CandidatePools;
+export declare type CandidatePoolsSelections = {
+    topByBaseWithTokenIn: SubgraphPool[];
+    topByBaseWithTokenOut: SubgraphPool[];
+    topByDirectSwapPool: SubgraphPool[];
+    topByEthQuoteTokenPool: SubgraphPool[];
+    topByTVL: SubgraphPool[];
+    topByTVLUsingTokenIn: SubgraphPool[];
+    topByTVLUsingTokenOut: SubgraphPool[];
+    topByTVLUsingTokenInSecondHops: SubgraphPool[];
+    topByTVLUsingTokenOutSecondHops: SubgraphPool[];
+};
+export declare type MixedCrossLiquidityCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    v2SubgraphProvider: IV2SubgraphProvider;
+    v3SubgraphProvider: IV3SubgraphProvider;
+    v2Candidates?: V2CandidatePools;
+    v3Candidates?: V3CandidatePools;
+    v4Candidates?: V4CandidatePools;
+    blockNumber?: number | Promise<number>;
+};
+export declare type V4GetCandidatePoolsParams = {
+    currencyIn: Currency;
+    currencyOut: Currency;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV4SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV4PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+    v4PoolParams?: Array<[number, number, string]>;
+};
+export declare type UniswapFewTokenV4GetCandidatePoolsParams = {
+    currencyIn: Currency;
+    currencyOut: Currency;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV4SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV4PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+    v4PoolParams?: Array<[number, number, string]>;
+};
+export declare type V3GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV3SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV3PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type UniswapFewTokenV3GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV3SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV3PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type V2GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV2SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV2PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type UniswapFewV2GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IV2SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IV2PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type RingFewV2GetCandidatePoolsParams = {
+    tokenIn: Token;
+    tokenOut: Token;
+    routeType: TradeType;
+    routingConfig: AlphaRouterConfig;
+    subgraphProvider: IRingV2SubgraphProvider;
+    tokenProvider: ITokenProvider;
+    poolProvider: IRingV2PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type MixedRouteGetCandidatePoolsParams = {
+    v4CandidatePools: V4CandidatePools | undefined;
+    v3CandidatePools: V3CandidatePools | undefined;
+    v2CandidatePools: V2CandidatePools | undefined;
+    crossLiquidityPools: CrossLiquidityCandidatePools;
+    routingConfig: AlphaRouterConfig;
+    tokenProvider: ITokenProvider;
+    v2poolProvider: IV2PoolProvider;
+    v3poolProvider: IV3PoolProvider;
+    v4PoolProvider: IV4PoolProvider;
+    blockedTokenListProvider?: ITokenListProvider;
+    chainId: ChainId;
+};
+export declare type CrossLiquidityCandidatePools = {
+    v2Pools: V2SubgraphPool[];
+    v3Pools: V3SubgraphPool[];
+};
+/**
+ * Function that finds any missing pools that were not selected by the heuristic but that would
+ *   create a route with the topPool by TVL with either tokenIn or tokenOut across protocols.
+ *
+ *   e.g. In V2CandidatePools we found that wstETH/DOG is the most liquid pool,
+ *        then in V3CandidatePools ETH/wstETH is *not* the most liquid pool, so it is not selected
+ *        This process will look for that pool in order to complete the route.
+ *
+ */
+export declare function getMixedCrossLiquidityCandidatePools({ tokenIn, tokenOut, blockNumber, v2SubgraphProvider, v3SubgraphProvider, v2Candidates, v3Candidates, }: MixedCrossLiquidityCandidatePoolsParams): Promise<CrossLiquidityCandidatePools>;
+export declare type UniswapFewTokenV4CandidatePools = {
+    poolAccessor: V4PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V4SubgraphPool[];
+};
+export declare type V4CandidatePools = {
+    poolAccessor: V4PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V4SubgraphPool[];
+};
+export declare function getV4CandidatePools({ currencyIn, currencyOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, v4PoolParams, }: V4GetCandidatePoolsParams): Promise<V4CandidatePools>;
+export declare function getUniswapV4FewTokenCandidatePools({ currencyIn, currencyOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, v4PoolParams, }: UniswapFewTokenV4GetCandidatePoolsParams): Promise<UniswapFewTokenV4CandidatePools>;
+export declare type V3CandidatePools = {
+    poolAccessor: V3PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V3SubgraphPool[];
+};
+export declare type UniswapFewTokenV3CandidatePools = {
+    poolAccessor: V3PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V3SubgraphPool[];
+};
+export declare function getV3CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: V3GetCandidatePoolsParams): Promise<V3CandidatePools>;
+export declare function getUniswapFewTokenV3CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: UniswapFewTokenV3GetCandidatePoolsParams): Promise<UniswapFewTokenV3CandidatePools>;
+export declare type V2CandidatePools = {
+    poolAccessor: V2PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V2SubgraphPool[];
+};
+export declare type UniswapFewV2CandidatePools = {
+    poolAccessor: V2PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: V2SubgraphPool[];
+};
+export declare function getV2CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: V2GetCandidatePoolsParams): Promise<V2CandidatePools>;
+export declare function getUniswapFewTokenV2CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: UniswapFewV2GetCandidatePoolsParams): Promise<UniswapFewV2CandidatePools>;
+export declare function getRingFewV2CandidatePools({ tokenIn, tokenOut, routeType, routingConfig, subgraphProvider, tokenProvider, poolProvider, blockedTokenListProvider, chainId, }: RingFewV2GetCandidatePoolsParams): Promise<RingFewV2CandidatePools>;
+export declare type RingFewV2CandidatePools = {
+    poolAccessor: RingFewV2PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: RingV2SubgraphPool[];
+};
+export declare type MixedCandidatePools = {
+    V2poolAccessor: V2PoolAccessor;
+    V3poolAccessor: V3PoolAccessor;
+    V4poolAccessor: V4PoolAccessor;
+    candidatePools: CandidatePoolsBySelectionCriteria;
+    subgraphPools: SubgraphPool[];
+};
+export declare function getMixedRouteCandidatePools({ v4CandidatePools, v3CandidatePools, v2CandidatePools, crossLiquidityPools, routingConfig, tokenProvider, v4PoolProvider, v3poolProvider, v2poolProvider, chainId, }: MixedRouteGetCandidatePoolsParams): Promise<MixedCandidatePools>;