@ring-protocol/smart-order-router 0.5.0

package/build/main/providers/v4/subgraph-provider.d.ts

@@ -0,0 +1,63 @@
+import { ChainId, Currency } from '@ring-protocol/sdk-core';
+import { ProviderConfig } from '../provider';
+import { SubgraphProvider } from '../subgraph-provider';
+export interface V4SubgraphPool {
+    id: string;
+    feeTier: string;
+    tickSpacing: string;
+    hooks: string;
+    liquidity: string;
+    token0: {
+        symbol?: string;
+        id: string;
+        name?: string;
+        decimals: string;
+    };
+    token1: {
+        symbol?: string;
+        id: string;
+        name?: string;
+        decimals: string;
+    };
+    tvlETH: number;
+    tvlUSD: number;
+}
+export declare type V4RawSubgraphPool = {
+    id: string;
+    feeTier: string;
+    tickSpacing: string;
+    hooks: string;
+    liquidity: string;
+    token0: {
+        symbol: string;
+        id: string;
+        name: string;
+        decimals: string;
+    };
+    token1: {
+        symbol: string;
+        id: string;
+        name: string;
+        decimals: string;
+    };
+    totalValueLockedUSD: string;
+    totalValueLockedETH: string;
+    totalValueLockedUSDUntracked: string;
+};
+export declare const SUBGRAPH_URL_BY_CHAIN: {
+    [chainId in ChainId]?: string;
+};
+/**
+ * Provider for getting V4 pools from the Subgraph
+ *
+ * @export
+ * @interface IV4SubgraphProvider
+ */
+export interface IV4SubgraphProvider {
+    getPools(currencyIn?: Currency, currencyOut?: Currency, providerConfig?: ProviderConfig): Promise<V4SubgraphPool[]>;
+}
+export declare class V4SubgraphProvider extends SubgraphProvider<V4RawSubgraphPool, V4SubgraphPool> implements IV4SubgraphProvider {
+    constructor(chainId: ChainId, retries?: number, timeout?: number, rollback?: boolean, trackedEthThreshold?: number, trackedZoraEthThreshold?: number, zoraHooks?: Set<string>, untrackedUsdThreshold?: number, subgraphUrlOverride?: string, bearerToken?: string);
+    protected mapSubgraphPool(rawPool: V4RawSubgraphPool): V4SubgraphPool;
+    protected getPoolFields(): string;
+}

package/build/main/providers/v4/subgraph-provider.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V4SubgraphProvider = exports.SUBGRAPH_URL_BY_CHAIN = void 0;
+const router_sdk_1 = require("@ring-protocol/router-sdk");
+const sdk_core_1 = require("@ring-protocol/sdk-core");
+const subgraph_provider_1 = require("../subgraph-provider");
+exports.SUBGRAPH_URL_BY_CHAIN = {
+    [sdk_core_1.ChainId.SEPOLIA]: '',
+};
+class V4SubgraphProvider extends subgraph_provider_1.SubgraphProvider {
+    constructor(chainId, retries = 2, timeout = 30000, rollback = true, trackedEthThreshold = 0.01, trackedZoraEthThreshold = 0.001, zoraHooks = new Set(), untrackedUsdThreshold = Number.MAX_VALUE, subgraphUrlOverride, bearerToken) {
+        super(router_sdk_1.Protocol.V4, chainId, retries, timeout, rollback, trackedEthThreshold, trackedZoraEthThreshold, zoraHooks, untrackedUsdThreshold, subgraphUrlOverride !== null && subgraphUrlOverride !== void 0 ? subgraphUrlOverride : exports.SUBGRAPH_URL_BY_CHAIN[chainId], bearerToken);
+    }
+    mapSubgraphPool(rawPool) {
+        return {
+            id: rawPool.id,
+            feeTier: rawPool.feeTier,
+            tickSpacing: rawPool.tickSpacing,
+            hooks: rawPool.hooks,
+            liquidity: rawPool.liquidity,
+            token0: {
+                symbol: rawPool.token0.symbol,
+                id: rawPool.token0.id,
+                name: rawPool.token0.name,
+                decimals: rawPool.token0.decimals,
+            },
+            token1: {
+                symbol: rawPool.token1.symbol,
+                id: rawPool.token1.id,
+                name: rawPool.token1.name,
+                decimals: rawPool.token1.decimals,
+            },
+            tvlETH: parseFloat(rawPool.totalValueLockedETH),
+            tvlUSD: parseFloat(rawPool.totalValueLockedUSD),
+        };
+    }
+    // Override to include V4-specific fields
+    getPoolFields() {
+        return `
+      id
+      token0 {
+        symbol
+        id
+        name
+        decimals
+      }
+      token1 {
+        symbol
+        id
+        name
+        decimals
+      }
+      feeTier
+      tickSpacing
+      hooks
+      liquidity
+      totalValueLockedUSD
+      totalValueLockedETH
+    `;
+    }
+}
+exports.V4SubgraphProvider = V4SubgraphProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ViZ3JhcGgtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3Y0L3N1YmdyYXBoLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDBEQUFxRDtBQUNyRCxzREFBNEQ7QUFHNUQsNERBQXdEO0FBK0MzQyxRQUFBLHFCQUFxQixHQUFzQztJQUN0RSxDQUFDLGtCQUFPLENBQUMsT0FBTyxDQUFDLEVBQUUsRUFBRTtDQUN0QixDQUFDO0FBZ0JGLE1BQWEsa0JBQ1gsU0FBUSxvQ0FBbUQ7SUFFM0QsWUFDRSxPQUFnQixFQUNoQixPQUFPLEdBQUcsQ0FBQyxFQUNYLE9BQU8sR0FBRyxLQUFLLEVBQ2YsUUFBUSxHQUFHLElBQUksRUFDZixtQkFBbUIsR0FBRyxJQUFJLEVBQzFCLHVCQUF1QixHQUFHLEtBQUssRUFDL0IsWUFBWSxJQUFJLEdBQUcsRUFBVSxFQUM3QixxQkFBcUIsR0FBRyxNQUFNLENBQUMsU0FBUyxFQUN4QyxtQkFBNEIsRUFDNUIsV0FBb0I7UUFFcEIsS0FBSyxDQUNILHFCQUFRLENBQUMsRUFBRSxFQUNYLE9BQU8sRUFDUCxPQUFPLEVBQ1AsT0FBTyxFQUNQLFFBQVEsRUFDUixtQkFBbUIsRUFDbkIsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxxQkFBcUIsRUFDckIsbUJBQW1CLGFBQW5CLG1CQUFtQixjQUFuQixtQkFBbUIsR0FBSSw2QkFBcUIsQ0FBQyxPQUFPLENBQUMsRUFDckQsV0FBVyxDQUNaLENBQUM7SUFDSixDQUFDO0lBRWtCLGVBQWUsQ0FDaEMsT0FBMEI7UUFFMUIsT0FBTztZQUNMLEVBQUUsRUFBRSxPQUFPLENBQUMsRUFBRTtZQUNkLE9BQU8sRUFBRSxPQUFPLENBQUMsT0FBTztZQUN4QixXQUFXLEVBQUUsT0FBTyxDQUFDLFdBQVc7WUFDaEMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1lBQ3BCLFNBQVMsRUFBRSxPQUFPLENBQUMsU0FBUztZQUM1QixNQUFNLEVBQUU7Z0JBQ04sTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsTUFBTTtnQkFDN0IsRUFBRSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRTtnQkFDckIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSTtnQkFDekIsUUFBUSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUTthQUNsQztZQUNELE1BQU0sRUFBRTtnQkFDTixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNO2dCQUM3QixFQUFFLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFO2dCQUNyQixJQUFJLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJO2dCQUN6QixRQUFRLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxRQUFRO2FBQ2xDO1lBQ0QsTUFBTSxFQUFFLFVBQVUsQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUM7WUFDL0MsTUFBTSxFQUFFLFVBQVUsQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUM7U0FDaEQsQ0FBQztJQUNKLENBQUM7SUFFRCx5Q0FBeUM7SUFDdEIsYUFBYTtRQUM5QixPQUFPOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztLQW9CTixDQUFDO0lBQ0osQ0FBQztDQUNGO0FBaEZELGdEQWdGQyJ9

package/build/main/providers/v4/uri-subgraph-provider.d.ts

@@ -0,0 +1,4 @@
+import { URISubgraphProvider } from '../uri-subgraph-provider';
+import { IV4SubgraphProvider, V4SubgraphPool } from './subgraph-provider';
+export declare class V4URISubgraphProvider extends URISubgraphProvider<V4SubgraphPool> implements IV4SubgraphProvider {
+}

package/build/main/providers/v4/uri-subgraph-provider.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V4URISubgraphProvider = void 0;
+const uri_subgraph_provider_1 = require("../uri-subgraph-provider");
+class V4URISubgraphProvider extends uri_subgraph_provider_1.URISubgraphProvider {
+}
+exports.V4URISubgraphProvider = V4URISubgraphProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJpLXN1YmdyYXBoLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy92NC91cmktc3ViZ3JhcGgtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsb0VBQStEO0FBRy9ELE1BQWEscUJBQ1gsU0FBUSwyQ0FBbUM7Q0FDVjtBQUZuQyxzREFFbUMifQ==

package/build/main/routers/alpha-router/alpha-router.d.ts

@@ -0,0 +1,483 @@
+import { BaseProvider } from '@ethersproject/providers';
+import { Protocol } from '@ring-protocol/router-sdk';
+import { ChainId, Currency, TradeType } from '@ring-protocol/sdk-core';
+import { Position } from '@ring-protocol/v3-sdk';
+import { CacheMode, IOnChainQuoteProvider, IRingV2PoolProvider, IRingV2QuoteProvider, IRingV2SubgraphProvider, IRouteCachingProvider, ISwapRouterProvider, ITokenPropertiesProvider, IV2QuoteProvider, IV2SubgraphProvider, IV4SubgraphProvider, RingswapMulticallProvider, SimulationStatus, Simulator, UniswapMulticallProvider } from '../../providers';
+import { ITokenListProvider } from '../../providers/caching-token-list-provider';
+import { IGasPriceProvider } from '../../providers/gas-price-provider';
+import { IPortionProvider } from '../../providers/portion-provider';
+import { ITokenProvider } from '../../providers/token-provider';
+import { ITokenValidatorProvider } from '../../providers/token-validator-provider';
+import { IV2PoolProvider } from '../../providers/v2/pool-provider';
+import { ArbitrumGasData, IL2GasDataProvider } from '../../providers/v3/gas-data-provider';
+import { IV3PoolProvider } from '../../providers/v3/pool-provider';
+import { IV3SubgraphProvider } from '../../providers/v3/subgraph-provider';
+import { IV4PoolProvider } from '../../providers/v4/pool-provider';
+import { HooksOptions } from '../../util';
+import { CurrencyAmount } from '../../util/amounts';
+import { IRouter, ISwapToRatio, SwapAndAddConfig, SwapAndAddOptions, SwapOptions, SwapRoute, SwapToRatioResponse } from '../router';
+import { UniversalRouterVersion } from '@ring-protocol/universal-router-sdk';
+import { INTENT } from '../../util/intent';
+import { MixedRouteWithValidQuote, RouteWithValidQuote, UniswapFewV3RouteWithValidQuote, UniswapFewV4RouteWithValidQuote, V3RouteWithValidQuote, V4RouteWithValidQuote } from './entities/route-with-valid-quote';
+import { IOnChainGasModelFactory, IV2GasModelFactory } from './gas-models/gas-model';
+import { MixedQuoter, V2Quoter, V3Quoter } from './quoters';
+import { V4Quoter } from './quoters/v4-quoter';
+import { UniswapFewV4Quoter } from './quoters/uniswap-few-v4-quoter';
+import { UniswapFewV3Quoter } from './quoters/uniswap-few-v3-quoter';
+import { IRingFewV2GasModelFactory } from './gas-models/ring-gas-model';
+import { RingFewV2Quoter } from './quoters/few-v2-quoter';
+export declare type AlphaRouterParams = {
+    /**
+     * The chain id for this instance of the Alpha Router.
+     */
+    chainId: ChainId;
+    /**
+     * The Web3 provider for getting on-chain data.
+     */
+    provider: BaseProvider;
+    /**
+     * The provider to use for making multicalls. Used for getting on-chain data
+     * like pools, tokens, quotes in batch.
+     */
+    multicall2Provider?: UniswapMulticallProvider;
+    /**
+     * The provider for getting all pools that exist on RingSwap Few V2 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    ringFewV2Multicall2Provider?: RingswapMulticallProvider;
+    /**
+     * The provider for getting all pools that exist on V4 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    v4SubgraphProvider?: IV4SubgraphProvider;
+    /**
+     * The provider for getting data about V4 pools.
+     */
+    v4PoolProvider?: IV4PoolProvider;
+    /**
+     * The provider for getting all pools that exist on V3 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    v3SubgraphProvider?: IV3SubgraphProvider;
+    /**
+     * The provider for getting data about V3 pools.
+     */
+    v3PoolProvider?: IV3PoolProvider;
+    /**
+     * The provider for getting V3 quotes.
+     */
+    onChainQuoteProvider?: IOnChainQuoteProvider;
+    /**
+     * The provider for getting all pools that exist on V2 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    v2SubgraphProvider?: IV2SubgraphProvider;
+    /**
+     * The provider for getting all pools that exist on RingSwap Few V2 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    ringFewV2SubgraphProvider?: IRingV2SubgraphProvider;
+    /**
+     * The provider for getting data about V2 pools.
+     */
+    v2PoolProvider?: IV2PoolProvider;
+    /**
+     * The provider for getting all pools that exist on RingSwap Few V2 from the Subgraph. The pools
+     * from this provider are filtered during the algorithm to a set of candidate pools.
+     */
+    ringFewV2PoolProvider?: IRingV2PoolProvider;
+    /**
+     * The provider for getting V3 quotes.
+     */
+    v2QuoteProvider?: IV2QuoteProvider;
+    /**
+     * The provider for getting data about RingSwap Few V2 pools.
+     */
+    ringFewV2QuoteProvider?: IRingV2QuoteProvider;
+    /**
+     * The provider for getting data about Tokens.
+     */
+    tokenProvider?: ITokenProvider;
+    /**
+     * The provider for getting the current gas price to use when account for gas in the
+     * algorithm.
+     */
+    gasPriceProvider?: IGasPriceProvider;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * V4 routes.
+     */
+    v4GasModelFactory?: IOnChainGasModelFactory<V4RouteWithValidQuote>;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * Uniswap Few V4 routes.
+     */
+    uniswapFewV4GasModelFactory?: IOnChainGasModelFactory<UniswapFewV4RouteWithValidQuote>;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * V3 routes.
+     */
+    v3GasModelFactory?: IOnChainGasModelFactory<V3RouteWithValidQuote>;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * Uniswap Few V3 routes.
+     */
+    uniswapFewV3GasModelFactory?: IOnChainGasModelFactory<UniswapFewV3RouteWithValidQuote>;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * V2 routes.
+     */
+    v2GasModelFactory?: IV2GasModelFactory;
+    /**
+     * The provider for getting RingSwap Few V2 quotes.
+     */
+    ringFewV2GasModelFactory?: IRingFewV2GasModelFactory;
+    /**
+     * A factory for generating a gas model that is used when estimating the gas used by
+     * V3 routes.
+     */
+    mixedRouteGasModelFactory?: IOnChainGasModelFactory<MixedRouteWithValidQuote>;
+    /**
+     * A token list that specifies Token that should be blocked from routing through.
+     * Defaults to Uniswap's unsupported token list.
+     */
+    blockedTokenListProvider?: ITokenListProvider;
+    /**
+     * Calls lens function on SwapRouter02 to determine ERC20 approval types for
+     * LP position tokens.
+     */
+    swapRouterProvider?: ISwapRouterProvider;
+    /**
+     * A token validator for detecting fee-on-transfer tokens or tokens that can't be transferred.
+     */
+    tokenValidatorProvider?: ITokenValidatorProvider;
+    /**
+     * Calls the arbitrum gas data contract to fetch constants for calculating the l1 fee.
+     */
+    arbitrumGasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    /**
+     * Simulates swaps and returns new SwapRoute with updated gas estimates.
+     */
+    simulator?: Simulator;
+    /**
+     * A provider for caching the best route given an amount, quoteToken, tradeType
+     */
+    routeCachingProvider?: IRouteCachingProvider;
+    /**
+     * A provider for getting token properties for special tokens like fee-on-transfer tokens.
+     */
+    tokenPropertiesProvider?: ITokenPropertiesProvider;
+    /**
+     * A provider for computing the portion-related data for routes and quotes.
+     */
+    portionProvider?: IPortionProvider;
+    /**
+     * All the supported v2 chains configuration
+     */
+    v2Supported?: ChainId[];
+    /**
+     * All the supported ring swap v2 chains configuration
+     */
+    ringFewV2Supported?: ChainId[];
+    /**
+     * All the supported v4 chains configuration
+     */
+    v4Supported?: ChainId[];
+    /**
+     * All the supported mixed chains configuration
+     */
+    mixedSupported?: ChainId[];
+    /**
+     * The v4 pool params to be used for the v4 pool provider.
+     * fee tiers, tickspacings, and hook addresses
+     */
+    v4PoolParams?: Array<[number, number, string]>;
+    /**
+     * We want to rollout the cached routes cache invalidation carefully.
+     * Because a wrong fix might impact prod success rate and/or latency.
+     */
+    cachedRoutesCacheInvalidationFixRolloutPercentage?: number;
+};
+export declare class MapWithLowerCaseKey<V> extends Map<string, V> {
+    set(key: string, value: V): this;
+}
+export declare class LowerCaseStringArray extends Array<string> {
+    constructor(...items: string[]);
+}
+/**
+ * Determines the pools that the algorithm will consider when finding the optimal swap.
+ *
+ * All pools on each protocol are filtered based on the heuristics specified here to generate
+ * the set of candidate pools. The Top N pools are taken by Total Value Locked (TVL).
+ *
+ * Higher values here result in more pools to explore which results in higher latency.
+ */
+export declare type ProtocolPoolSelection = {
+    /**
+     * The top N pools by TVL out of all pools on the protocol.
+     */
+    topN: number;
+    /**
+     * The top N pools by TVL of pools that consist of tokenIn and tokenOut.
+     */
+    topNDirectSwaps: number;
+    /**
+     * The top N pools by TVL of pools where one token is tokenIn and the
+     * top N pools by TVL of pools where one token is tokenOut tokenOut.
+     */
+    topNTokenInOut: number;
+    /**
+     * Given the topNTokenInOut pools, gets the top N pools that involve the other token.
+     * E.g. for a WETH -> USDC swap, if topNTokenInOut found WETH -> DAI and WETH -> USDT,
+     * a value of 2 would find the top 2 pools that involve DAI and top 2 pools that involve USDT.
+     */
+    topNSecondHop: number;
+    /**
+     * Given the topNTokenInOut pools and a token address,
+     * gets the top N pools that involve the other token.
+     * If token address is not on the list, we default to topNSecondHop.
+     * E.g. for a WETH -> USDC swap, if topNTokenInOut found WETH -> DAI and WETH -> USDT,
+     * and there's a mapping USDT => 4, but no mapping for DAI
+     * it would find the top 4 pools that involve USDT, and find the topNSecondHop pools that involve DAI
+     */
+    topNSecondHopForTokenAddress?: MapWithLowerCaseKey<number>;
+    /**
+     * List of token addresses to avoid using as a second hop.
+     * There might be multiple reasons why we would like to avoid a specific token,
+     *   but the specific reason that we are trying to solve is when the pool is not synced properly
+     *   e.g. when the pool has a rebasing token that isn't syncing the pool on every rebase.
+     */
+    tokensToAvoidOnSecondHops?: LowerCaseStringArray;
+    /**
+     * The top N pools for token in and token out that involve a token from a list of
+     * hardcoded 'base tokens'. These are standard tokens such as WETH, USDC, DAI, etc.
+     * This is similar to how the legacy routing algorithm used by Uniswap would select
+     * pools and is intended to make the new pool selection algorithm close to a superset
+     * of the old algorithm.
+     */
+    topNWithEachBaseToken: number;
+    /**
+     * Given the topNWithEachBaseToken pools, takes the top N pools from the full list.
+     * E.g. for a WETH -> USDC swap, if topNWithEachBaseToken found WETH -0.05-> DAI,
+     * WETH -0.01-> DAI, WETH -0.05-> USDC, WETH -0.3-> USDC, a value of 2 would reduce
+     * this set to the top 2 pools from that full list.
+     */
+    topNWithBaseToken: number;
+};
+export declare type AlphaRouterConfig = {
+    /**
+     * The block number to use for all on-chain data. If not provided, the router will
+     * use the latest block returned by the provider.
+     */
+    blockNumber?: number | Promise<number>;
+    /**
+     * The protocols to consider when finding the optimal swap. If not provided all protocols
+     * will be used.
+     */
+    protocols?: Protocol[];
+    /**
+     * The protocols-version pools to be excluded from the mixed routes.
+     */
+    excludedProtocolsFromMixed?: Protocol[];
+    /**
+     * Config for selecting which pools to consider routing via on V2.
+     */
+    v2PoolSelection: ProtocolPoolSelection;
+    /**
+     * Config for selecting which pools to consider routing via on V3.
+     */
+    v3PoolSelection: ProtocolPoolSelection;
+    /**
+     * Config for selecting which pools to consider routing via on V4.
+     */
+    v4PoolSelection: ProtocolPoolSelection;
+    /**
+     * For each route, the maximum number of hops to consider. More hops will increase latency of the algorithm.
+     */
+    maxSwapsPerPath: number;
+    /**
+     * The maximum number of splits in the returned route. A higher maximum will increase latency of the algorithm.
+     */
+    maxSplits: number;
+    /**
+     * The minimum number of splits in the returned route.
+     * This parameters should always be set to 1. It is only included for testing purposes.
+     */
+    minSplits: number;
+    /**
+     * Forces the returned swap to route across all protocols.
+     * This parameter should always be false. It is only included for testing purposes.
+     */
+    forceCrossProtocol: boolean;
+    /**
+     * Force the alpha router to choose a mixed route swap.
+     * Default will be falsy. It is only included for testing purposes.
+     */
+    forceMixedRoutes?: boolean;
+    /**
+     * The minimum percentage of the input token to use for each route in a split route.
+     * All routes will have a multiple of this value. For example is distribution percentage is 5,
+     * a potential return swap would be:
+     *
+     * 5% of input => Route 1
+     * 55% of input => Route 2
+     * 40% of input => Route 3
+     */
+    distributionPercent: number;
+    /**
+     * Flag to indicate whether to use the cached routes or not.
+     * By default, the cached routes will be used.
+     */
+    useCachedRoutes?: boolean;
+    /**
+     * Flag to indicate whether to write to the cached routes or not.
+     * By default, the cached routes will be written to.
+     */
+    writeToCachedRoutes?: boolean;
+    /**
+     * Flag to indicate whether to use the CachedRoutes in optimistic mode.
+     * Optimistic mode means that we will allow blocksToLive greater than 1.
+     */
+    optimisticCachedRoutes?: boolean;
+    /**
+     * Debug param that helps to see the short-term latencies improvements without impacting the main path.
+     */
+    debugRouting?: boolean;
+    /**
+     * Flag that allow us to override the cache mode.
+     */
+    overwriteCacheMode?: CacheMode;
+    /**
+     * Flag for token properties provider to enable fetching fee-on-transfer tokens.
+     */
+    enableFeeOnTransferFeeFetching?: boolean;
+    /**
+     * Tenderly natively support save simulation failures if failed,
+     * we need this as a pass-through flag to enable/disable this feature.
+     */
+    saveTenderlySimulationIfFailed?: boolean;
+    /**
+     * Include an additional response field specifying the swap gas estimation in terms of a specific gas token.
+     * This requires a suitable Native/GasToken pool to exist on V3. If one does not exist this field will return null.
+     */
+    gasToken?: string;
+    /**
+     * The version of the universal router to use.
+     */
+    universalRouterVersion?: UniversalRouterVersion;
+    /**
+     * pass in routing-api intent to align the intent between routing-api and SOR
+     */
+    intent?: INTENT;
+    /**
+     * boolean flag to control whether we should enable mixed route that connects ETH <-> WETH
+     */
+    shouldEnableMixedRouteEthWeth?: boolean;
+    /**
+     * hashed router ids of the cached route, if the online routing lambda uses the cached route to serve the quote
+     */
+    cachedRoutesRouteIds?: string;
+    /**
+     * enable mixed route with UR1_2 version backward compatibility issue
+     */
+    enableMixedRouteWithUR1_2?: boolean;
+    /**
+     * enable debug mode for async routing lambda
+     */
+    enableDebug?: boolean;
+    /**
+     * pass in hooks options for hooks routing toggles from the frontend
+     */
+    hooksOptions?: HooksOptions;
+};
+export declare class AlphaRouter implements IRouter<AlphaRouterConfig>, ISwapToRatio<AlphaRouterConfig, SwapAndAddConfig> {
+    protected chainId: ChainId;
+    protected provider: BaseProvider;
+    protected multicall2Provider: UniswapMulticallProvider;
+    protected ringFewV2Multicall2Provider: RingswapMulticallProvider;
+    protected v4SubgraphProvider: IV4SubgraphProvider;
+    protected v4PoolProvider: IV4PoolProvider;
+    protected v3SubgraphProvider: IV3SubgraphProvider;
+    protected v3PoolProvider: IV3PoolProvider;
+    protected onChainQuoteProvider: IOnChainQuoteProvider;
+    protected v2SubgraphProvider: IV2SubgraphProvider;
+    protected ringFewV2SubgraphProvider: IRingV2SubgraphProvider;
+    protected v2QuoteProvider: IV2QuoteProvider;
+    protected ringFewV2QuoteProvider: IRingV2QuoteProvider;
+    protected v2PoolProvider: IV2PoolProvider;
+    protected ringFewV2PoolProvider: IRingV2PoolProvider;
+    protected tokenProvider: ITokenProvider;
+    protected gasPriceProvider: IGasPriceProvider;
+    protected swapRouterProvider: ISwapRouterProvider;
+    protected v4GasModelFactory: IOnChainGasModelFactory<V4RouteWithValidQuote>;
+    protected uniswapFewV4GasModelFactory: IOnChainGasModelFactory<UniswapFewV4RouteWithValidQuote>;
+    protected v3GasModelFactory: IOnChainGasModelFactory<V3RouteWithValidQuote>;
+    protected uniswapFewV3GasModelFactory: IOnChainGasModelFactory<UniswapFewV3RouteWithValidQuote>;
+    protected v2GasModelFactory: IV2GasModelFactory;
+    protected ringFewV2GasModelFactory: IRingFewV2GasModelFactory;
+    protected mixedRouteGasModelFactory: IOnChainGasModelFactory<MixedRouteWithValidQuote>;
+    protected tokenValidatorProvider?: ITokenValidatorProvider;
+    protected blockedTokenListProvider?: ITokenListProvider;
+    protected l2GasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    protected simulator?: Simulator;
+    protected v2Quoter: V2Quoter;
+    protected ringFewV2Quoter: RingFewV2Quoter;
+    protected v3Quoter: V3Quoter;
+    protected uniswapFewV3Quoter: UniswapFewV3Quoter;
+    protected v4Quoter: V4Quoter;
+    protected uniswapFewV4Quoter: UniswapFewV4Quoter;
+    protected mixedQuoter: MixedQuoter;
+    protected routeCachingProvider?: IRouteCachingProvider;
+    protected tokenPropertiesProvider: ITokenPropertiesProvider;
+    protected portionProvider: IPortionProvider;
+    protected v2Supported?: ChainId[];
+    protected ringFewV2Supported?: ChainId[];
+    protected v4Supported?: ChainId[];
+    protected mixedSupported?: ChainId[];
+    protected v4PoolParams?: Array<[number, number, string]>;
+    protected cachedRoutesCacheInvalidationFixRolloutPercentage?: number;
+    protected shouldEnableMixedRouteEthWeth?: boolean;
+    constructor({ chainId, provider, multicall2Provider, ringFewV2Multicall2Provider, v4SubgraphProvider, v4PoolProvider, v3PoolProvider, onChainQuoteProvider, v2PoolProvider, ringFewV2PoolProvider, v2QuoteProvider, ringFewV2QuoteProvider, v2SubgraphProvider, ringFewV2SubgraphProvider, tokenProvider, blockedTokenListProvider, v3SubgraphProvider, gasPriceProvider, v4GasModelFactory, uniswapFewV4GasModelFactory, v3GasModelFactory, uniswapFewV3GasModelFactory, v2GasModelFactory, ringFewV2GasModelFactory, mixedRouteGasModelFactory, swapRouterProvider, tokenValidatorProvider, arbitrumGasDataProvider, simulator, routeCachingProvider, tokenPropertiesProvider, portionProvider, v2Supported, ringFewV2Supported, v4Supported, mixedSupported, v4PoolParams, cachedRoutesCacheInvalidationFixRolloutPercentage, }: AlphaRouterParams);
+    routeToRatio(token0Balance: CurrencyAmount, token1Balance: CurrencyAmount, position: Position, swapAndAddConfig: SwapAndAddConfig, swapAndAddOptions?: SwapAndAddOptions, routingConfig?: Partial<AlphaRouterConfig>): Promise<SwapToRatioResponse>;
+    /**
+     * @inheritdoc IRouter
+     */
+    route(amount: CurrencyAmount, quoteCurrency: Currency, tradeType: TradeType, swapConfig?: SwapOptions, partialRoutingConfig?: Partial<AlphaRouterConfig>): Promise<SwapRoute | null>;
+    /**
+     * Performs the caching intention for the given simulation status and route.
+     *
+     * @param currencyIn the currency in
+     * @param currencyOut the currency out
+     * @param tradeType the trade type
+     * @param amount the amount
+     * @param protocols the protocols
+     * @param blockNumber the block number
+     * @param routingConfig the routing config
+     * @param simulationStatus the simulation status
+     * @param simulationRoute the simulation route
+     */
+    protected performCachingIntention(currencyIn: Currency, currencyOut: Currency, tradeType: TradeType, amount: CurrencyAmount, protocols: Protocol[], blockNumber: number, routingConfig: AlphaRouterConfig, simulationStatus: SimulationStatus, simulationRoute: RouteWithValidQuote[]): Promise<void>;
+    /**
+     * @param simulationStatus the status of the simulation
+     * @returns true if the route should be cached, false otherwise
+     */
+    protected shouldCacheRoute(simulationStatus: SimulationStatus): boolean;
+    private setCachedRoutesAndLog;
+    private getSwapRouteFromCache;
+    private getUniswapFewTokenSwapRouteFromCache;
+    private getSwapRouteFromChain;
+    private getUniswapFewTokenSwapRouteFromChain;
+    private tradeTypeStr;
+    private tokenPairSymbolTradeTypeChainId;
+    private determineCurrencyInOutFromTradeType;
+    private getGasPriceWei;
+    private getGasModels;
+    private getAmountDistribution;
+    private buildSwapAndAddMethodParameters;
+    private emitPoolSelectionMetrics;
+    private calculateOptimalRatio;
+    userHasSufficientBalance(fromAddress: string, tradeType: TradeType, amount: CurrencyAmount, quote: CurrencyAmount): Promise<boolean>;
+    private absoluteValue;
+    private getBlockNumberPromise;
+    static isAllowedToEnterCachedRoutes(intent?: INTENT, hooksOptions?: HooksOptions, swapRouter?: boolean): boolean;
+}