@ring-protocol/smart-order-router 0.5.0

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

@@ -0,0 +1,3 @@
+import { Fraction } from '@ring-protocol/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("@ring-protocol/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yb3V0ZXJzL2FscGhhLXJvdXRlci9mdW5jdGlvbnMvY2FsY3VsYXRlLXJhdGlvLWFtb3VudC1pbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBbUQ7QUFFbkQsbURBQXVEO0FBRXZELFNBQWdCLHNCQUFzQixDQUNwQyxZQUFzQixFQUN0QixlQUF5QixFQUN6QixZQUE0QixFQUM1QixhQUE2QjtJQUU3QixvSEFBb0g7SUFDcEgsTUFBTSxlQUFlLEdBQUcsSUFBSSxtQkFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUM7U0FDeEQsUUFBUSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1NBQ3ZELE1BQU0sQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXpELElBQUksZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsRUFBRTtRQUMvQiwyREFBMkQ7UUFDM0QsTUFBTSxJQUFJLEtBQUssQ0FBQywrQ0FBK0MsQ0FBQyxDQUFDO0tBQ2xFO0lBRUQsT0FBTyx3QkFBYyxDQUFDLGFBQWEsQ0FDakMsWUFBWSxDQUFDLFFBQVEsRUFDckIsZUFBZSxDQUFDLFFBQVEsQ0FDekIsQ0FBQztBQUNKLENBQUM7QUFwQkQsd0RBb0JDIn0=

package/build/main/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/main/routers/alpha-router/functions/compute-all-routes.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAllRoutes = exports.computeAllMixedRoutes = exports.computeAllRingFewV2Routes = exports.computeAllV2Routes = exports.computeAllUniswapFewV3Routes = exports.computeAllV3Routes = exports.computeAllUniswapFewV4Routes = exports.computeAllV4Routes = void 0;
+const router_sdk_1 = require("@ring-protocol/router-sdk");
+const v2_sdk_1 = require("@ring-protocol/v2-sdk");
+const v3_sdk_1 = require("@ring-protocol/v3-sdk");
+const v4_sdk_1 = require("@ring-protocol/v4-sdk");
+const util_1 = require("../../../util");
+const hooksOptions_1 = require("../../../util/hooksOptions");
+const log_1 = require("../../../util/log");
+const routes_1 = require("../../../util/routes");
+const router_1 = require("../../router");
+function computeAllV4Routes(currencyIn, currencyOut, pools, maxHops, hooksOptions) {
+    let filteredPools = pools;
+    if (hooksOptions === hooksOptions_1.HooksOptions.HOOKS_ONLY) {
+        filteredPools = pools.filter((pool) => pool.hooks !== router_sdk_1.ADDRESS_ZERO);
+    }
+    if (hooksOptions === hooksOptions_1.HooksOptions.NO_HOOKS) {
+        filteredPools = pools.filter((pool) => pool.hooks === router_sdk_1.ADDRESS_ZERO);
+    }
+    return computeAllRoutes(currencyIn, currencyOut, (route, currencyIn, currencyOut) => {
+        return new router_1.V4Route(route, currencyIn, currencyOut);
+    }, (pool, currency) => pool.involvesToken(currency), filteredPools, maxHops);
+}
+exports.computeAllV4Routes = computeAllV4Routes;
+function computeAllUniswapFewV4Routes(currencyIn, currencyOut, pools, maxHops, hooksOptions) {
+    let filteredPools = pools;
+    if (hooksOptions === hooksOptions_1.HooksOptions.HOOKS_ONLY) {
+        filteredPools = pools.filter((pool) => pool.hooks !== router_sdk_1.ADDRESS_ZERO);
+    }
+    if (hooksOptions === hooksOptions_1.HooksOptions.NO_HOOKS) {
+        filteredPools = pools.filter((pool) => pool.hooks === router_sdk_1.ADDRESS_ZERO);
+    }
+    return computeAllRoutes(currencyIn, currencyOut, (route, currencyIn, currencyOut) => {
+        return new router_1.V4Route(route, currencyIn, currencyOut);
+    }, (pool, currency) => pool.involvesToken(currency), filteredPools, maxHops);
+}
+exports.computeAllUniswapFewV4Routes = computeAllUniswapFewV4Routes;
+function computeAllV3Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.V3Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+exports.computeAllV3Routes = computeAllV3Routes;
+function computeAllUniswapFewV3Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.V3Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+exports.computeAllUniswapFewV3Routes = computeAllUniswapFewV3Routes;
+function computeAllV2Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.V2Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+exports.computeAllV2Routes = computeAllV2Routes;
+function computeAllRingFewV2Routes(tokenIn, tokenOut, pools, maxHops) {
+    return computeAllRoutes(tokenIn, tokenOut, (route, tokenIn, tokenOut) => {
+        return new router_1.RingFewV2Route(route, tokenIn, tokenOut);
+    }, (pool, token) => pool.involvesToken(token), pools, maxHops);
+}
+exports.computeAllRingFewV2Routes = computeAllRingFewV2Routes;
+function computeAllMixedRoutes(currencyIn, currencyOut, parts, maxHops, shouldEnableMixedRouteEthWeth, hooksOptions) {
+    // first we need to filter non v4-pools
+    const filteredPools = !hooksOptions || hooksOptions === hooksOptions_1.HooksOptions.HOOKS_INCLUSIVE
+        ? parts
+        : parts.filter((pool) => !(pool instanceof v4_sdk_1.Pool));
+    if (hooksOptions === hooksOptions_1.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 v4_sdk_1.Pool && pool.hooks !== router_sdk_1.ADDRESS_ZERO);
+        parts = filteredPools.concat(v4HookslessPools);
+    }
+    if (hooksOptions === hooksOptions_1.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 v4_sdk_1.Pool && pool.hooks === router_sdk_1.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 v4_sdk_1.Pool &&
+        pool.v4InvolvesToken((0, util_1.nativeOnChain)(currencyIn.chainId))).length > 0;
+    const amendedPools = containsV4NativePools && shouldEnableMixedRouteEthWeth
+        ? parts.concat(util_1.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 router_1.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 v4_sdk_1.Pool) &&
+            !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, 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 v4_sdk_1.Pool &&
+            pool.tickSpacing ===
+                util_1.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((0, util_1.getAddressLowerCase)(currentTokenOut))) {
+                continue;
+            }
+            tokensVisited.add((0, util_1.getAddressLowerCase)(currentTokenOut));
+            currentRoute.push(curPool);
+            poolsUsed[i] = true;
+            computeRoutes(tokenIn, tokenOut, currentRoute, poolsUsed, tokensVisited, currentTokenOut);
+            poolsUsed[i] = false;
+            currentRoute.pop();
+            tokensVisited.delete((0, util_1.getAddressLowerCase)(currentTokenOut));
+        }
+    };
+    computeRoutes(tokenIn, tokenOut, [], poolsUsed, new Set([(0, util_1.getAddressLowerCase)(tokenIn)]));
+    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,{"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/main/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>;