@hkdex-tmp/smart-order-router 4.31.0

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

@@ -0,0 +1,1681 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import DEFAULT_TOKEN_LIST from '@uniswap/default-token-list';
+import { Protocol, SwapRouter, ZERO, } from '@uniswap/router-sdk';
+import { ChainId, Fraction, TradeType, } from '@uniswap/sdk-core';
+import { UniversalRouterVersion } from '@uniswap/universal-router-sdk';
+import { Pair as V2Pool } from '@uniswap/v2-sdk';
+import { Pool, Pool as V3Pool, Position, SqrtPriceMath, TickMath, } from '@uniswap/v3-sdk';
+import { Pool as V4Pool } from '@uniswap/v4-sdk';
+import retry from 'async-retry';
+import JSBI from 'jsbi';
+import _ from 'lodash';
+import NodeCache from 'node-cache';
+import { CachedRoutes, CacheMode, CachingGasStationProvider, CachingTokenProviderWithFallback, CachingV2PoolProvider, CachingV2SubgraphProvider, CachingV3PoolProvider, CachingV3SubgraphProvider, CachingV4SubgraphProvider, EIP1559GasPriceProvider, ETHGasStationInfoProvider, LegacyGasPriceProvider, NodeJSCache, OnChainGasPriceProvider, OnChainQuoteProvider, SimulationStatus, StaticV2SubgraphProvider, StaticV3SubgraphProvider, StaticV4SubgraphProvider, SwapRouterProvider, TokenPropertiesProvider, UniswapMulticallProvider, URISubgraphProvider, V2QuoteProvider, V2SubgraphProviderWithFallBacks, V3SubgraphProviderWithFallBacks, V4SubgraphProviderWithFallBacks, } from '../../providers';
+import { CachingTokenListProvider, } from '../../providers/caching-token-list-provider';
+import { PortionProvider, } from '../../providers/portion-provider';
+import { OnChainTokenFeeFetcher } from '../../providers/token-fee-fetcher';
+import { TokenProvider } from '../../providers/token-provider';
+import { TokenValidatorProvider, } from '../../providers/token-validator-provider';
+import { V2PoolProvider, } from '../../providers/v2/pool-provider';
+import { ArbitrumGasDataProvider, } from '../../providers/v3/gas-data-provider';
+import { V3PoolProvider, } from '../../providers/v3/pool-provider';
+import { CachingV4PoolProvider } from '../../providers/v4/caching-pool-provider';
+import { V4PoolProvider, } from '../../providers/v4/pool-provider';
+import { Erc20__factory } from '../../types/other/factories/Erc20__factory';
+import { getAddress, getAddressLowerCase, getApplicableV4FeesTickspacingsHooks, HooksOptions, MIXED_CROSS_LIQUIDITY_V3_AGAINST_V4_SUPPORTED, MIXED_SUPPORTED, shouldWipeoutCachedRoutes, SWAP_ROUTER_02_ADDRESSES, V4_SUPPORTED, WRAPPED_NATIVE_CURRENCY, } from '../../util';
+import { CurrencyAmount } from '../../util/amounts';
+import { ID_TO_CHAIN_ID, ID_TO_NETWORK_NAME, V2_SUPPORTED, } from '../../util/chains';
+import { DEFAULT_BLOCKS_TO_LIVE } from '../../util/defaultBlocksToLive';
+import { getHighestLiquidityV3NativePool, getHighestLiquidityV3USDPool, } from '../../util/gas-factory-helpers';
+import { INTENT } from '../../util/intent';
+import { log } from '../../util/log';
+import { buildSwapMethodParameters, buildTrade, } from '../../util/methodParameters';
+import { metric, MetricLoggerUnit } from '../../util/metric';
+import { BATCH_PARAMS, BLOCK_NUMBER_CONFIGS, DEFAULT_BATCH_PARAMS, DEFAULT_BLOCK_NUMBER_CONFIGS, DEFAULT_GAS_ERROR_FAILURE_OVERRIDES, DEFAULT_RETRY_OPTIONS, DEFAULT_SUCCESS_RATE_FAILURE_OVERRIDES, GAS_ERROR_FAILURE_OVERRIDES, RETRY_OPTIONS, SUCCESS_RATE_FAILURE_OVERRIDES, } from '../../util/onchainQuoteProviderConfigs';
+import { serializeRouteIds } from '../../util/serializeRouteIds';
+import { UNSUPPORTED_TOKENS } from '../../util/unsupported-tokens';
+import { cloneMixedRouteWithNewPools, cloneV2RouteWithNewPools, cloneV3RouteWithNewPools, cloneV4RouteWithNewPools, SwapToRatioStatus, SwapType, } from '../router';
+import { DEFAULT_ROUTING_CONFIG_BY_CHAIN, ETH_GAS_STATION_API_URL, } from './config';
+import { getBestSwapRoute } from './functions/best-swap-route';
+import { calculateRatioAmountIn } from './functions/calculate-ratio-amount-in';
+import { getMixedCrossLiquidityCandidatePools, getV2CandidatePools, getV3CandidatePools, getV4CandidatePools, } from './functions/get-candidate-pools';
+import { NATIVE_OVERHEAD } from './gas-models/gas-costs';
+import { MixedRouteHeuristicGasModelFactory } from './gas-models/mixedRoute/mixed-route-heuristic-gas-model';
+import { V2HeuristicGasModelFactory } from './gas-models/v2/v2-heuristic-gas-model';
+import { V3HeuristicGasModelFactory } from './gas-models/v3/v3-heuristic-gas-model';
+import { V4HeuristicGasModelFactory } from './gas-models/v4/v4-heuristic-gas-model';
+import { MixedQuoter, V2Quoter, V3Quoter } from './quoters';
+import { V4Quoter } from './quoters/v4-quoter';
+export class MapWithLowerCaseKey extends Map {
+    set(key, value) {
+        return super.set(key.toLowerCase(), value);
+    }
+}
+export class LowerCaseStringArray extends Array {
+    constructor(...items) {
+        // Convert all items to lowercase before calling the parent constructor
+        super(...items.map((item) => item.toLowerCase()));
+    }
+}
+export class AlphaRouter {
+    constructor({ chainId, provider, multicall2Provider, v4SubgraphProvider, v4PoolProvider, v3PoolProvider, onChainQuoteProvider, v2PoolProvider, v2QuoteProvider, v2SubgraphProvider, tokenProvider, blockedTokenListProvider, v3SubgraphProvider, gasPriceProvider, v4GasModelFactory, v3GasModelFactory, v2GasModelFactory, mixedRouteGasModelFactory, swapRouterProvider, tokenValidatorProvider, arbitrumGasDataProvider, simulator, routeCachingProvider, tokenPropertiesProvider, portionProvider, v2Supported, v4Supported, mixedSupported, mixedCrossLiquidityV3AgainstV4Supported, v4PoolParams, cachedRoutesCacheInvalidationFixRolloutPercentage, deleteCacheEnabledChains, }) {
+        this.chainId = chainId;
+        this.provider = provider;
+        this.multicall2Provider =
+            multicall2Provider !== null && multicall2Provider !== void 0 ? multicall2Provider : new UniswapMulticallProvider(chainId, provider, 375000);
+        this.v4PoolProvider =
+            v4PoolProvider !== null && v4PoolProvider !== void 0 ? v4PoolProvider : new CachingV4PoolProvider(this.chainId, new V4PoolProvider(ID_TO_CHAIN_ID(chainId), this.multicall2Provider), new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false })));
+        this.v3PoolProvider =
+            v3PoolProvider !== null && v3PoolProvider !== void 0 ? v3PoolProvider : new CachingV3PoolProvider(this.chainId, new V3PoolProvider(ID_TO_CHAIN_ID(chainId), this.multicall2Provider), new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false })));
+        this.simulator = simulator;
+        this.routeCachingProvider = routeCachingProvider;
+        if (onChainQuoteProvider) {
+            this.onChainQuoteProvider = onChainQuoteProvider;
+        }
+        else {
+            switch (chainId) {
+                case ChainId.OPTIMISM:
+                case ChainId.OPTIMISM_GOERLI:
+                case ChainId.OPTIMISM_SEPOLIA:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, (_) => {
+                        return {
+                            multicallChunk: 110,
+                            gasLimitPerCall: 1200000,
+                            quoteMinSuccessRate: 0.1,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 3000000,
+                            multicallChunk: 45,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 3000000,
+                            multicallChunk: 45,
+                        };
+                    }, (_) => {
+                        return {
+                            baseBlockOffset: -10,
+                            rollback: {
+                                enabled: true,
+                                attemptsBeforeRollback: 1,
+                                rollbackBlockOffset: -10,
+                            },
+                        };
+                    });
+                    break;
+                case ChainId.BASE:
+                case ChainId.BLAST:
+                case ChainId.ZORA:
+                case ChainId.WORLDCHAIN:
+                case ChainId.UNICHAIN_SEPOLIA:
+                case ChainId.MONAD_TESTNET:
+                case ChainId.MONAD:
+                case ChainId.BASE_SEPOLIA:
+                case ChainId.UNICHAIN:
+                case ChainId.BASE_GOERLI:
+                case ChainId.SONEIUM:
+                case ChainId.XLAYER:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, (_) => {
+                        return {
+                            multicallChunk: 80,
+                            gasLimitPerCall: 1200000,
+                            quoteMinSuccessRate: 0.1,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 3000000,
+                            multicallChunk: 45,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 3000000,
+                            multicallChunk: 45,
+                        };
+                    }, (_) => {
+                        return {
+                            baseBlockOffset: -10,
+                            rollback: {
+                                enabled: true,
+                                attemptsBeforeRollback: 1,
+                                rollbackBlockOffset: -10,
+                            },
+                        };
+                    });
+                    break;
+                case ChainId.ZKSYNC:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, (_) => {
+                        return {
+                            multicallChunk: 27,
+                            gasLimitPerCall: 3000000,
+                            quoteMinSuccessRate: 0.1,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 6000000,
+                            multicallChunk: 13,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 6000000,
+                            multicallChunk: 13,
+                        };
+                    }, (_) => {
+                        return {
+                            baseBlockOffset: -10,
+                            rollback: {
+                                enabled: true,
+                                attemptsBeforeRollback: 1,
+                                rollbackBlockOffset: -10,
+                            },
+                        };
+                    });
+                    break;
+                case ChainId.ARBITRUM_ONE:
+                case ChainId.ARBITRUM_GOERLI:
+                case ChainId.ARBITRUM_SEPOLIA:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, (_) => {
+                        return {
+                            multicallChunk: 10,
+                            gasLimitPerCall: 12000000,
+                            quoteMinSuccessRate: 0.1,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 30000000,
+                            multicallChunk: 6,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 30000000,
+                            multicallChunk: 6,
+                        };
+                    });
+                    break;
+                case ChainId.CELO:
+                case ChainId.CELO_ALFAJORES:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, (_) => {
+                        return {
+                            multicallChunk: 10,
+                            gasLimitPerCall: 5000000,
+                            quoteMinSuccessRate: 0.1,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 5000000,
+                            multicallChunk: 5,
+                        };
+                    }, (_) => {
+                        return {
+                            gasLimitOverride: 6250000,
+                            multicallChunk: 4,
+                        };
+                    });
+                    break;
+                case ChainId.POLYGON_MUMBAI:
+                case ChainId.SEPOLIA:
+                case ChainId.MAINNET:
+                case ChainId.POLYGON:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, RETRY_OPTIONS[chainId], (_) => BATCH_PARAMS[chainId], (_) => GAS_ERROR_FAILURE_OVERRIDES[chainId], (_) => SUCCESS_RATE_FAILURE_OVERRIDES[chainId], (_) => BLOCK_NUMBER_CONFIGS[chainId]);
+                    break;
+                default:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, DEFAULT_RETRY_OPTIONS, (_) => DEFAULT_BATCH_PARAMS, (_) => DEFAULT_GAS_ERROR_FAILURE_OVERRIDES, (_) => DEFAULT_SUCCESS_RATE_FAILURE_OVERRIDES, (_) => DEFAULT_BLOCK_NUMBER_CONFIGS);
+                    break;
+            }
+        }
+        if (tokenValidatorProvider) {
+            this.tokenValidatorProvider = tokenValidatorProvider;
+        }
+        else if (this.chainId === ChainId.MAINNET) {
+            this.tokenValidatorProvider = new TokenValidatorProvider(this.chainId, this.multicall2Provider, new NodeJSCache(new NodeCache({ stdTTL: 30000, useClones: false })));
+        }
+        if (tokenPropertiesProvider) {
+            this.tokenPropertiesProvider = tokenPropertiesProvider;
+        }
+        else {
+            this.tokenPropertiesProvider = new TokenPropertiesProvider(this.chainId, new NodeJSCache(new NodeCache({ stdTTL: 86400, useClones: false })), new OnChainTokenFeeFetcher(this.chainId, provider));
+        }
+        this.v2PoolProvider =
+            v2PoolProvider !== null && v2PoolProvider !== void 0 ? v2PoolProvider : new CachingV2PoolProvider(chainId, new V2PoolProvider(chainId, this.multicall2Provider, this.tokenPropertiesProvider), new NodeJSCache(new NodeCache({ stdTTL: 60, useClones: false })));
+        this.v2QuoteProvider = v2QuoteProvider !== null && v2QuoteProvider !== void 0 ? v2QuoteProvider : new V2QuoteProvider();
+        this.blockedTokenListProvider =
+            blockedTokenListProvider !== null && blockedTokenListProvider !== void 0 ? blockedTokenListProvider : new CachingTokenListProvider(chainId, UNSUPPORTED_TOKENS, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false })));
+        this.tokenProvider =
+            tokenProvider !== null && tokenProvider !== void 0 ? tokenProvider : new CachingTokenProviderWithFallback(chainId, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false })), new CachingTokenListProvider(chainId, DEFAULT_TOKEN_LIST, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false }))), new TokenProvider(chainId, this.multicall2Provider));
+        this.portionProvider = portionProvider !== null && portionProvider !== void 0 ? portionProvider : new PortionProvider();
+        const chainName = ID_TO_NETWORK_NAME(chainId);
+        // ipfs urls in the following format: `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/${protocol}/${chainName}.json`;
+        if (v2SubgraphProvider) {
+            this.v2SubgraphProvider = v2SubgraphProvider;
+        }
+        else {
+            this.v2SubgraphProvider = new V2SubgraphProviderWithFallBacks([
+                new CachingV2SubgraphProvider(chainId, new URISubgraphProvider(chainId, `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/v2/${chainName}.json`, undefined, 0), new NodeJSCache(new NodeCache({ stdTTL: 300, useClones: false }))),
+                new StaticV2SubgraphProvider(chainId),
+            ]);
+        }
+        if (v3SubgraphProvider) {
+            this.v3SubgraphProvider = v3SubgraphProvider;
+        }
+        else {
+            this.v3SubgraphProvider = new V3SubgraphProviderWithFallBacks([
+                new CachingV3SubgraphProvider(chainId, new URISubgraphProvider(chainId, `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/v3/${chainName}.json`, undefined, 0), new NodeJSCache(new NodeCache({ stdTTL: 300, useClones: false }))),
+                new StaticV3SubgraphProvider(chainId, this.v3PoolProvider),
+            ]);
+        }
+        this.v4PoolParams =
+            v4PoolParams !== null && v4PoolParams !== void 0 ? v4PoolParams : getApplicableV4FeesTickspacingsHooks(chainId);
+        if (v4SubgraphProvider) {
+            this.v4SubgraphProvider = v4SubgraphProvider;
+        }
+        else {
+            this.v4SubgraphProvider = new V4SubgraphProviderWithFallBacks([
+                new CachingV4SubgraphProvider(chainId, new URISubgraphProvider(chainId, `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/v4/${chainName}.json`, undefined, 0), new NodeJSCache(new NodeCache({ stdTTL: 300, useClones: false }))),
+                new StaticV4SubgraphProvider(chainId, this.v4PoolProvider, this.v4PoolParams),
+            ]);
+        }
+        let gasPriceProviderInstance;
+        if (JsonRpcProvider.isProvider(this.provider)) {
+            gasPriceProviderInstance = new OnChainGasPriceProvider(chainId, new EIP1559GasPriceProvider(this.provider), new LegacyGasPriceProvider(this.provider));
+        }
+        else {
+            gasPriceProviderInstance = new ETHGasStationInfoProvider(ETH_GAS_STATION_API_URL);
+        }
+        this.gasPriceProvider =
+            gasPriceProvider !== null && gasPriceProvider !== void 0 ? gasPriceProvider : new CachingGasStationProvider(chainId, gasPriceProviderInstance, new NodeJSCache(new NodeCache({ stdTTL: 7, useClones: false })));
+        this.v4GasModelFactory =
+            v4GasModelFactory !== null && v4GasModelFactory !== void 0 ? v4GasModelFactory : new V4HeuristicGasModelFactory(this.provider);
+        this.v3GasModelFactory =
+            v3GasModelFactory !== null && v3GasModelFactory !== void 0 ? v3GasModelFactory : new V3HeuristicGasModelFactory(this.provider);
+        this.v2GasModelFactory =
+            v2GasModelFactory !== null && v2GasModelFactory !== void 0 ? v2GasModelFactory : new V2HeuristicGasModelFactory(this.provider);
+        this.mixedRouteGasModelFactory =
+            mixedRouteGasModelFactory !== null && mixedRouteGasModelFactory !== void 0 ? mixedRouteGasModelFactory : new MixedRouteHeuristicGasModelFactory();
+        this.swapRouterProvider =
+            swapRouterProvider !== null && swapRouterProvider !== void 0 ? swapRouterProvider : new SwapRouterProvider(this.multicall2Provider, this.chainId);
+        if (chainId === ChainId.ARBITRUM_ONE ||
+            chainId === ChainId.ARBITRUM_GOERLI) {
+            this.l2GasDataProvider =
+                arbitrumGasDataProvider !== null && arbitrumGasDataProvider !== void 0 ? arbitrumGasDataProvider : new ArbitrumGasDataProvider(chainId, this.provider);
+        }
+        // Initialize the Quoters.
+        // Quoters are an abstraction encapsulating the business logic of fetching routes and quotes.
+        this.v2Quoter = new V2Quoter(this.v2SubgraphProvider, this.v2PoolProvider, this.v2QuoteProvider, this.v2GasModelFactory, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider, this.l2GasDataProvider);
+        this.v3Quoter = new V3Quoter(this.v3SubgraphProvider, this.v3PoolProvider, this.onChainQuoteProvider, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+        this.v4Quoter = new V4Quoter(this.v4SubgraphProvider, this.v4PoolProvider, this.onChainQuoteProvider, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+        this.mixedQuoter = new MixedQuoter(this.v4SubgraphProvider, this.v4PoolProvider, this.v3SubgraphProvider, this.v3PoolProvider, this.v2SubgraphProvider, this.v2PoolProvider, this.onChainQuoteProvider, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+        this.v2Supported = v2Supported !== null && v2Supported !== void 0 ? v2Supported : V2_SUPPORTED;
+        this.v4Supported = v4Supported !== null && v4Supported !== void 0 ? v4Supported : V4_SUPPORTED;
+        this.mixedSupported = mixedSupported !== null && mixedSupported !== void 0 ? mixedSupported : MIXED_SUPPORTED;
+        this.mixedCrossLiquidityV3AgainstV4Supported =
+            mixedCrossLiquidityV3AgainstV4Supported !== null && mixedCrossLiquidityV3AgainstV4Supported !== void 0 ? mixedCrossLiquidityV3AgainstV4Supported : MIXED_CROSS_LIQUIDITY_V3_AGAINST_V4_SUPPORTED;
+        this.cachedRoutesCacheInvalidationFixRolloutPercentage =
+            cachedRoutesCacheInvalidationFixRolloutPercentage;
+        // https://linear.app/uniswap/issue/ROUTE-467/tenderly-simulation-during-caching-lambda
+        this.deleteCacheEnabledChains = deleteCacheEnabledChains;
+    }
+    async routeToRatio(token0Balance, token1Balance, position, swapAndAddConfig, swapAndAddOptions, routingConfig = DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId)) {
+        if (token1Balance.currency.wrapped.sortsBefore(token0Balance.currency.wrapped)) {
+            [token0Balance, token1Balance] = [token1Balance, token0Balance];
+        }
+        let preSwapOptimalRatio = this.calculateOptimalRatio(position, position.pool.sqrtRatioX96, true);
+        // set up parameters according to which token will be swapped
+        let zeroForOne;
+        if (position.pool.tickCurrent > position.tickUpper) {
+            zeroForOne = true;
+        }
+        else if (position.pool.tickCurrent < position.tickLower) {
+            zeroForOne = false;
+        }
+        else {
+            zeroForOne = new Fraction(token0Balance.quotient, token1Balance.quotient).greaterThan(preSwapOptimalRatio);
+            if (!zeroForOne)
+                preSwapOptimalRatio = preSwapOptimalRatio.invert();
+        }
+        const [inputBalance, outputBalance] = zeroForOne
+            ? [token0Balance, token1Balance]
+            : [token1Balance, token0Balance];
+        let optimalRatio = preSwapOptimalRatio;
+        let postSwapTargetPool = position.pool;
+        let exchangeRate = zeroForOne
+            ? position.pool.token0Price
+            : position.pool.token1Price;
+        let swap = null;
+        let ratioAchieved = false;
+        let n = 0;
+        // iterate until we find a swap with a sufficient ratio or return null
+        while (!ratioAchieved) {
+            n++;
+            if (n > swapAndAddConfig.maxIterations) {
+                log.info('max iterations exceeded');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'max iterations exceeded',
+                };
+            }
+            const amountToSwap = calculateRatioAmountIn(optimalRatio, exchangeRate, inputBalance, outputBalance);
+            if (amountToSwap.equalTo(0)) {
+                log.info(`no swap needed: amountToSwap = 0`);
+                return {
+                    status: SwapToRatioStatus.NO_SWAP_NEEDED,
+                };
+            }
+            swap = await this.route(amountToSwap, outputBalance.currency, TradeType.EXACT_INPUT, undefined, {
+                ...DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId),
+                ...routingConfig,
+                /// @dev We do not want to query for mixedRoutes for routeToRatio as they are not supported
+                /// [Protocol.V3, Protocol.V2] will make sure we only query for V3 and V2
+                protocols: [Protocol.V3, Protocol.V2],
+            });
+            if (!swap) {
+                log.info('no route found from this.route()');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'no route found',
+                };
+            }
+            const inputBalanceUpdated = inputBalance.subtract(swap.trade.inputAmount);
+            const outputBalanceUpdated = outputBalance.add(swap.trade.outputAmount);
+            const newRatio = inputBalanceUpdated.divide(outputBalanceUpdated);
+            let targetPoolPriceUpdate;
+            swap.route.forEach((route) => {
+                if (route.protocol === Protocol.V3) {
+                    const v3Route = route;
+                    v3Route.route.pools.forEach((pool, i) => {
+                        if (pool.token0.equals(position.pool.token0) &&
+                            pool.token1.equals(position.pool.token1) &&
+                            pool.fee === position.pool.fee) {
+                            targetPoolPriceUpdate = JSBI.BigInt(v3Route.sqrtPriceX96AfterList[i].toString());
+                            optimalRatio = this.calculateOptimalRatio(position, JSBI.BigInt(targetPoolPriceUpdate.toString()), zeroForOne);
+                        }
+                    });
+                }
+            });
+            if (!targetPoolPriceUpdate) {
+                optimalRatio = preSwapOptimalRatio;
+            }
+            ratioAchieved =
+                newRatio.equalTo(optimalRatio) ||
+                    this.absoluteValue(newRatio.asFraction.divide(optimalRatio).subtract(1)).lessThan(swapAndAddConfig.ratioErrorTolerance);
+            if (ratioAchieved && targetPoolPriceUpdate) {
+                postSwapTargetPool = new Pool(position.pool.token0, position.pool.token1, position.pool.fee, targetPoolPriceUpdate, position.pool.liquidity, TickMath.getTickAtSqrtRatio(targetPoolPriceUpdate), position.pool.tickDataProvider);
+            }
+            exchangeRate = swap.trade.outputAmount.divide(swap.trade.inputAmount);
+            log.info({
+                exchangeRate: exchangeRate.asFraction.toFixed(18),
+                optimalRatio: optimalRatio.asFraction.toFixed(18),
+                newRatio: newRatio.asFraction.toFixed(18),
+                inputBalanceUpdated: inputBalanceUpdated.asFraction.toFixed(18),
+                outputBalanceUpdated: outputBalanceUpdated.asFraction.toFixed(18),
+                ratioErrorTolerance: swapAndAddConfig.ratioErrorTolerance.toFixed(18),
+                iterationN: n.toString(),
+            }, 'QuoteToRatio Iteration Parameters');
+            if (exchangeRate.equalTo(0)) {
+                log.info('exchangeRate to 0');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'insufficient liquidity to swap to optimal ratio',
+                };
+            }
+        }
+        if (!swap) {
+            return {
+                status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                error: 'no route found',
+            };
+        }
+        let methodParameters;
+        if (swapAndAddOptions) {
+            methodParameters = await this.buildSwapAndAddMethodParameters(swap.trade, swapAndAddOptions, {
+                initialBalanceTokenIn: inputBalance,
+                initialBalanceTokenOut: outputBalance,
+                preLiquidityPosition: position,
+            });
+        }
+        return {
+            status: SwapToRatioStatus.SUCCESS,
+            result: { ...swap, methodParameters, optimalRatio, postSwapTargetPool },
+        };
+    }
+    /**
+     * @inheritdoc IRouter
+     */
+    async route(amount, quoteCurrency, tradeType, swapConfig, partialRoutingConfig = {}) {
+        var _a, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
+        const originalAmount = amount;
+        const { currencyIn, currencyOut } = this.determineCurrencyInOutFromTradeType(tradeType, amount, quoteCurrency);
+        const tokenOutProperties = await this.tokenPropertiesProvider.getTokensProperties([currencyOut], partialRoutingConfig);
+        const feeTakenOnTransfer = (_c = (_a = tokenOutProperties[getAddressLowerCase(currencyOut)]) === null || _a === void 0 ? void 0 : _a.tokenFeeResult) === null || _c === void 0 ? void 0 : _c.feeTakenOnTransfer;
+        const externalTransferFailed = (_e = (_d = tokenOutProperties[getAddressLowerCase(currencyOut)]) === null || _d === void 0 ? void 0 : _d.tokenFeeResult) === null || _e === void 0 ? void 0 : _e.externalTransferFailed;
+        // We want to log the fee on transfer output tokens that we are taking fee or not
+        // Ideally the trade size (normalized in USD) would be ideal to log here, but we don't have spot price of output tokens here.
+        // We have to make sure token out is FOT with either buy/sell fee bps > 0
+        if (((_h = (_g = (_f = tokenOutProperties[getAddressLowerCase(currencyOut)]) === null || _f === void 0 ? void 0 : _f.tokenFeeResult) === null || _g === void 0 ? void 0 : _g.buyFeeBps) === null || _h === void 0 ? void 0 : _h.gt(0)) ||
+            ((_l = (_k = (_j = tokenOutProperties[getAddressLowerCase(currencyOut)]) === null || _j === void 0 ? void 0 : _j.tokenFeeResult) === null || _k === void 0 ? void 0 : _k.sellFeeBps) === null || _l === void 0 ? void 0 : _l.gt(0))) {
+            if (feeTakenOnTransfer || externalTransferFailed) {
+                // also to be extra safe, in case of FOT with feeTakenOnTransfer or externalTransferFailed,
+                // we nullify the fee and flat fee to avoid any potential issues.
+                // although neither web nor wallet should use the calldata returned from routing/SOR
+                if ((swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.type) === SwapType.UNIVERSAL_ROUTER) {
+                    swapConfig.fee = undefined;
+                    swapConfig.flatFee = undefined;
+                }
+                metric.putMetric('TokenOutFeeOnTransferNotTakingFee', 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric('TokenOutFeeOnTransferTakingFee', 1, MetricLoggerUnit.Count);
+            }
+        }
+        if (tradeType === TradeType.EXACT_OUTPUT) {
+            const portionAmount = this.portionProvider.getPortionAmount(amount, tradeType, feeTakenOnTransfer, externalTransferFailed, swapConfig);
+            if (portionAmount && portionAmount.greaterThan(ZERO)) {
+                // In case of exact out swap, before we route, we need to make sure that the
+                // token out amount accounts for flat portion, and token in amount after the best swap route contains the token in equivalent of portion.
+                // In other words, in case a pool's LP fee bps is lower than the portion bps (0.01%/0.05% for v3), a pool can go insolvency.
+                // This is because instead of the swapper being responsible for the portion,
+                // the pool instead gets responsible for the portion.
+                // The addition below avoids that situation.
+                amount = amount.add(portionAmount);
+            }
+        }
+        metric.setProperty('chainId', this.chainId);
+        metric.setProperty('pair', `${currencyIn.symbol}/${currencyOut.symbol}`);
+        metric.setProperty('tokenIn', getAddress(currencyIn));
+        metric.setProperty('tokenOut', getAddress(currencyOut));
+        metric.setProperty('tradeType', tradeType === TradeType.EXACT_INPUT ? 'ExactIn' : 'ExactOut');
+        metric.putMetric(`QuoteRequestedForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+        // Get a block number to specify in all our calls. Ensures data we fetch from chain is
+        // from the same block.
+        const blockNumber = (_m = partialRoutingConfig.blockNumber) !== null && _m !== void 0 ? _m : this.getBlockNumberPromise();
+        const routingConfig = _.merge({
+            // These settings could be changed by the partialRoutingConfig
+            useCachedRoutes: true,
+            writeToCachedRoutes: true,
+            optimisticCachedRoutes: false,
+        }, DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId), partialRoutingConfig, { blockNumber });
+        if (routingConfig.debugRouting) {
+            log.warn(`Finalized routing config is ${JSON.stringify(routingConfig)}`);
+        }
+        const gasPriceWei = await this.getGasPriceWei(await blockNumber, await partialRoutingConfig.blockNumber);
+        // const gasTokenAccessor = await this.tokenProvider.getTokens([routingConfig.gasToken!]);
+        const gasToken = routingConfig.gasToken
+            ? (await this.tokenProvider.getTokens([routingConfig.gasToken])).getTokenByAddress(routingConfig.gasToken)
+            : undefined;
+        const providerConfig = {
+            ...routingConfig,
+            blockNumber,
+            additionalGasOverhead: NATIVE_OVERHEAD(this.chainId, amount.currency, quoteCurrency),
+            gasToken,
+            externalTransferFailed,
+            feeTakenOnTransfer,
+        };
+        const { v2GasModel: v2GasModel, v3GasModel: v3GasModel, v4GasModel: v4GasModel, mixedRouteGasModel: mixedRouteGasModel, } = await this.getGasModels(gasPriceWei, amount.currency.wrapped, quoteCurrency.wrapped, providerConfig);
+        // Create a Set to sanitize the protocols input, a Set of undefined becomes an empty set,
+        // Then create an Array from the values of that Set.
+        const protocols = Array.from(new Set(routingConfig.protocols).values());
+        const cacheMode = (_o = routingConfig.overwriteCacheMode) !== null && _o !== void 0 ? _o : (await ((_p = this.routeCachingProvider) === null || _p === void 0 ? void 0 : _p.getCacheMode(this.chainId, amount, quoteCurrency, tradeType, protocols)));
+        // Fetch CachedRoutes
+        let cachedRoutes;
+        // Decide whether to use cached routes or not - If |enabledAndRequestedProtocolsMatch| is true we are good to use cached routes.
+        // In order to use cached routes, we need to have all enabled protocols specified in the request.
+        // By default, all protocols are enabled but for UniversalRouterVersion.V1_2, V4 is not.
+        // - ref: https://github.com/Uniswap/routing-api/blob/663b607d80d9249f85e7ab0925a611ec3701da2a/lib/util/supportedProtocolVersions.ts#L15
+        // So we take this into account when deciding whether to use cached routes or not.
+        // We only want to use cache if all enabled protocols are specified (V2,V3,V4? + MIXED). In any other case, use onchain path.
+        // - Cache is optimized for global search, not for specific protocol(s) search.
+        // For legacy systems (SWAP_ROUTER_02) or missing swapConfig, follow UniversalRouterVersion.V1_2 logic.
+        const availableProtocolsSet = new Set(Object.values(Protocol));
+        const requestedProtocolsSet = new Set(protocols);
+        const swapRouter = !swapConfig ||
+            swapConfig.type === SwapType.SWAP_ROUTER_02 ||
+            (swapConfig.type === SwapType.UNIVERSAL_ROUTER &&
+                swapConfig.version === UniversalRouterVersion.V1_2);
+        if (swapRouter) {
+            availableProtocolsSet.delete(Protocol.V4);
+            if (requestedProtocolsSet.has(Protocol.V4)) {
+                requestedProtocolsSet.delete(Protocol.V4);
+            }
+        }
+        const enabledAndRequestedProtocolsMatch = availableProtocolsSet.size === requestedProtocolsSet.size &&
+            [...availableProtocolsSet].every((protocol) => requestedProtocolsSet.has(protocol));
+        // If the requested protocols do not match the enabled protocols, we need to set the hooks options to NO_HOOKS.
+        if (!requestedProtocolsSet.has(Protocol.V4)) {
+            routingConfig.hooksOptions = HooksOptions.NO_HOOKS;
+        }
+        // If hooksOptions not specified and it's not a swapRouter (i.e. Universal Router it is),
+        // we should also set it to HOOKS_INCLUSIVE, as this is default behavior even without hooksOptions.
+        if (!routingConfig.hooksOptions) {
+            routingConfig.hooksOptions = HooksOptions.HOOKS_INCLUSIVE;
+        }
+        log.debug('UniversalRouterVersion_CacheGate_Check', {
+            availableProtocolsSet: Array.from(availableProtocolsSet),
+            requestedProtocolsSet: Array.from(requestedProtocolsSet),
+            enabledAndRequestedProtocolsMatch,
+            swapConfigType: swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.type,
+            swapConfigUniversalRouterVersion: (swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.type) === SwapType.UNIVERSAL_ROUTER
+                ? swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.version
+                : 'N/A',
+        });
+        if (routingConfig.useCachedRoutes &&
+            cacheMode !== CacheMode.Darkmode &&
+            AlphaRouter.isAllowedToEnterCachedRoutes(routingConfig.intent, routingConfig.hooksOptions, swapRouter)) {
+            if (enabledAndRequestedProtocolsMatch) {
+                if (protocols.includes(Protocol.V4) &&
+                    (currencyIn.isNative || currencyOut.isNative)) {
+                    const [wrappedNativeCachedRoutes, nativeCachedRoutes] = await Promise.all([
+                        (_q = this.routeCachingProvider) === null || _q === void 0 ? void 0 : _q.getCachedRoute(this.chainId, CurrencyAmount.fromRawAmount(amount.currency.wrapped, amount.quotient), quoteCurrency.wrapped, tradeType, protocols, await blockNumber, routingConfig.optimisticCachedRoutes, routingConfig, swapConfig),
+                        (_r = this.routeCachingProvider) === null || _r === void 0 ? void 0 : _r.getCachedRoute(this.chainId, amount, quoteCurrency, tradeType, [Protocol.V4], await blockNumber, routingConfig.optimisticCachedRoutes, routingConfig, swapConfig),
+                    ]);
+                    if ((wrappedNativeCachedRoutes &&
+                        (wrappedNativeCachedRoutes === null || wrappedNativeCachedRoutes === void 0 ? void 0 : wrappedNativeCachedRoutes.routes.length) > 0) ||
+                        (nativeCachedRoutes && (nativeCachedRoutes === null || nativeCachedRoutes === void 0 ? void 0 : nativeCachedRoutes.routes.length) > 0)) {
+                        cachedRoutes = new CachedRoutes({
+                            routes: [
+                                ...((_s = nativeCachedRoutes === null || nativeCachedRoutes === void 0 ? void 0 : nativeCachedRoutes.routes) !== null && _s !== void 0 ? _s : []),
+                                ...((_t = wrappedNativeCachedRoutes === null || wrappedNativeCachedRoutes === void 0 ? void 0 : wrappedNativeCachedRoutes.routes) !== null && _t !== void 0 ? _t : []),
+                            ],
+                            chainId: this.chainId,
+                            currencyIn: currencyIn,
+                            currencyOut: currencyOut,
+                            protocolsCovered: protocols,
+                            blockNumber: await blockNumber,
+                            tradeType: tradeType,
+                            originalAmount: (_v = (_u = wrappedNativeCachedRoutes === null || wrappedNativeCachedRoutes === void 0 ? void 0 : wrappedNativeCachedRoutes.originalAmount) !== null && _u !== void 0 ? _u : nativeCachedRoutes === null || nativeCachedRoutes === void 0 ? void 0 : nativeCachedRoutes.originalAmount) !== null && _v !== void 0 ? _v : amount.quotient.toString(),
+                            blocksToLive: (_x = (_w = wrappedNativeCachedRoutes === null || wrappedNativeCachedRoutes === void 0 ? void 0 : wrappedNativeCachedRoutes.blocksToLive) !== null && _w !== void 0 ? _w : nativeCachedRoutes === null || nativeCachedRoutes === void 0 ? void 0 : nativeCachedRoutes.blocksToLive) !== null && _x !== void 0 ? _x : DEFAULT_BLOCKS_TO_LIVE[this.chainId],
+                        });
+                    }
+                }
+                else {
+                    cachedRoutes = await ((_y = this.routeCachingProvider) === null || _y === void 0 ? void 0 : _y.getCachedRoute(this.chainId, amount, quoteCurrency, tradeType, protocols, await blockNumber, routingConfig.optimisticCachedRoutes, routingConfig, swapConfig));
+                }
+            }
+        }
+        if (shouldWipeoutCachedRoutes(cachedRoutes, routingConfig)) {
+            cachedRoutes = undefined;
+        }
+        metric.putMetric(routingConfig.useCachedRoutes
+            ? 'GetQuoteUsingCachedRoutes'
+            : 'GetQuoteNotUsingCachedRoutes', 1, MetricLoggerUnit.Count);
+        if (cacheMode &&
+            routingConfig.useCachedRoutes &&
+            cacheMode !== CacheMode.Darkmode &&
+            !cachedRoutes) {
+            metric.putMetric(`GetCachedRoute_miss_${cacheMode}`, 1, MetricLoggerUnit.Count);
+            log.info({
+                currencyIn: currencyIn.symbol,
+                currencyInAddress: getAddress(currencyIn),
+                currencyOut: currencyOut.symbol,
+                currencyOutAddress: getAddress(currencyOut),
+                cacheMode,
+                amount: amount.toExact(),
+                chainId: this.chainId,
+                tradeType: this.tradeTypeStr(tradeType),
+            }, `GetCachedRoute miss ${cacheMode} for ${this.tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType)}`);
+        }
+        else if (cachedRoutes && routingConfig.useCachedRoutes) {
+            metric.putMetric(`GetCachedRoute_hit_${cacheMode}`, 1, MetricLoggerUnit.Count);
+            log.info({
+                currencyIn: currencyIn.symbol,
+                currencyInAddress: getAddress(currencyIn),
+                currencyOut: currencyOut.symbol,
+                currencyOutAddress: getAddress(currencyOut),
+                cacheMode,
+                amount: amount.toExact(),
+                chainId: this.chainId,
+                tradeType: this.tradeTypeStr(tradeType),
+            }, `GetCachedRoute hit ${cacheMode} for ${this.tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType)}`);
+        }
+        let swapRouteFromCachePromise = Promise.resolve(null);
+        if (cachedRoutes) {
+            swapRouteFromCachePromise = this.getSwapRouteFromCache(currencyIn, currencyOut, cachedRoutes, await blockNumber, amount, quoteCurrency, tradeType, routingConfig, v3GasModel, v4GasModel, mixedRouteGasModel, gasPriceWei, v2GasModel, swapConfig, providerConfig);
+        }
+        let swapRouteFromChainPromise = Promise.resolve(null);
+        if (!cachedRoutes || cacheMode !== CacheMode.Livemode) {
+            swapRouteFromChainPromise = this.getSwapRouteFromChain(amount, currencyIn, currencyOut, protocols, quoteCurrency, tradeType, routingConfig, v3GasModel, v4GasModel, mixedRouteGasModel, gasPriceWei, v2GasModel, swapConfig, providerConfig);
+        }
+        const [swapRouteFromCache, swapRouteFromChain] = await Promise.all([
+            swapRouteFromCachePromise,
+            swapRouteFromChainPromise,
+        ]);
+        let swapRouteRaw;
+        let hitsCachedRoute = false;
+        if (cacheMode === CacheMode.Livemode && swapRouteFromCache) {
+            // offline lambda is never in cache mode
+            // refresh pools to avoid stale data
+            const beforeRefreshPools = Date.now();
+            await this.refreshPools(swapRouteFromCache.routes, routingConfig, this.v2PoolProvider, this.v3PoolProvider, this.v4PoolProvider);
+            metric.putMetric(`Route_RefreshPools_Latency`, Date.now() - beforeRefreshPools, MetricLoggerUnit.Milliseconds);
+            log.info(`CacheMode is ${cacheMode}, and we are using swapRoute from cache`);
+            hitsCachedRoute = true;
+            swapRouteRaw = swapRouteFromCache;
+        }
+        else {
+            log.info(`CacheMode is ${cacheMode}, and we are using materialized swapRoute`);
+            swapRouteRaw = swapRouteFromChain;
+        }
+        if (cacheMode === CacheMode.Tapcompare &&
+            swapRouteFromCache &&
+            swapRouteFromChain) {
+            const quoteDiff = swapRouteFromChain.quote.subtract(swapRouteFromCache.quote);
+            const quoteGasAdjustedDiff = swapRouteFromChain.quoteGasAdjusted.subtract(swapRouteFromCache.quoteGasAdjusted);
+            const gasUsedDiff = swapRouteFromChain.estimatedGasUsed.sub(swapRouteFromCache.estimatedGasUsed);
+            // Only log if quoteDiff is different from 0, or if quoteGasAdjustedDiff and gasUsedDiff are both different from 0
+            if (!quoteDiff.equalTo(0) ||
+                !(quoteGasAdjustedDiff.equalTo(0) || gasUsedDiff.eq(0))) {
+                try {
+                    // Calculates the percentage of the difference with respect to the quoteFromChain (not from cache)
+                    const misquotePercent = quoteGasAdjustedDiff
+                        .divide(swapRouteFromChain.quoteGasAdjusted)
+                        .multiply(100);
+                    metric.putMetric(`TapcompareCachedRoute_quoteGasAdjustedDiffPercent`, Number(misquotePercent.toExact()), MetricLoggerUnit.Percent);
+                    log.warn({
+                        quoteFromChain: swapRouteFromChain.quote.toExact(),
+                        quoteFromCache: swapRouteFromCache.quote.toExact(),
+                        quoteDiff: quoteDiff.toExact(),
+                        quoteGasAdjustedFromChain: swapRouteFromChain.quoteGasAdjusted.toExact(),
+                        quoteGasAdjustedFromCache: swapRouteFromCache.quoteGasAdjusted.toExact(),
+                        quoteGasAdjustedDiff: quoteGasAdjustedDiff.toExact(),
+                        gasUsedFromChain: swapRouteFromChain.estimatedGasUsed.toString(),
+                        gasUsedFromCache: swapRouteFromCache.estimatedGasUsed.toString(),
+                        gasUsedDiff: gasUsedDiff.toString(),
+                        routesFromChain: swapRouteFromChain.routes.toString(),
+                        routesFromCache: swapRouteFromCache.routes.toString(),
+                        amount: amount.toExact(),
+                        originalAmount: cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.originalAmount,
+                        pair: this.tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType),
+                        blockNumber,
+                    }, `Comparing quotes between Chain and Cache for ${this.tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType)}`);
+                }
+                catch (error) {
+                    // This is in response to the 'division by zero' error
+                    // during https://uniswapteam.slack.com/archives/C059TGEC57W/p1723997015399579
+                    if (error instanceof RangeError &&
+                        error.message.includes('Division by zero')) {
+                        log.error({
+                            quoteGasAdjustedDiff: quoteGasAdjustedDiff.toExact(),
+                            swapRouteFromChainQuoteGasAdjusted: swapRouteFromChain.quoteGasAdjusted.toExact(),
+                        }, 'Error calculating misquote percent');
+                        metric.putMetric(`TapcompareCachedRoute_quoteGasAdjustedDiffPercent_divzero`, 1, MetricLoggerUnit.Count);
+                    }
+                    // Log but don't throw here - this is only for logging.
+                }
+            }
+        }
+        let newSetCachedRoutesPath = false;
+        const shouldEnableCachedRoutesCacheInvalidationFix = Math.random() * 100 <
+            ((_z = this.cachedRoutesCacheInvalidationFixRolloutPercentage) !== null && _z !== void 0 ? _z : 0);
+        // we have to write cached routes right before checking swapRouteRaw is null or not
+        // because getCachedRoutes in routing-api do not use the blocks-to-live to filter out the expired routes at all
+        // there's a possibility the cachedRoutes is always populated, but swapRouteFromCache is always null, because we don't update cachedRoutes in this case at all,
+        // as long as it's within 24 hours sliding window TTL
+        if (shouldEnableCachedRoutesCacheInvalidationFix) {
+            // theoretically, when routingConfig.intent === INTENT.CACHING, optimisticCachedRoutes should be false
+            // so that we can always pass in cachedRoutes?.notExpired(await blockNumber, !routingConfig.optimisticCachedRoutes)
+            // but just to be safe, we just hardcode true when checking the cached routes expiry for write update
+            // we decide to not check cached routes expiry in the read path anyway
+            if (!(cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.notExpired(await blockNumber, true))) {
+                // optimisticCachedRoutes === false means at routing-api level, we only want to set cached routes during intent=caching, not intent=quote
+                // this means during the online quote endpoint path, we should not reset cached routes
+                if (routingConfig.intent === INTENT.CACHING) {
+                    // due to fire and forget nature, we already take note that we should set new cached routes during the new path
+                    newSetCachedRoutesPath = true;
+                    metric.putMetric(`SetCachedRoute_NewPath`, 1, MetricLoggerUnit.Count);
+                    // there's a chance that swapRouteFromChain might be populated already,
+                    // when there's no cachedroutes in the dynamo DB.
+                    // in that case, we don't try to swap route from chain again
+                    const swapRouteFromChainAgain = swapRouteFromChain !== null && swapRouteFromChain !== void 0 ? swapRouteFromChain : 
+                    // we have to intentionally await here, because routing-api lambda has a chance to return the swapRoute/swapRouteWithSimulation
+                    // before the routing-api quote handler can finish running getSwapRouteFromChain (getSwapRouteFromChain is runtime intensive)
+                    (await this.getSwapRouteFromChain(amount, currencyIn, currencyOut, protocols, quoteCurrency, tradeType, routingConfig, v3GasModel, v4GasModel, mixedRouteGasModel, gasPriceWei, v2GasModel, swapConfig, providerConfig));
+                    if (swapRouteFromChainAgain) {
+                        const routesToCache = CachedRoutes.fromRoutesWithValidQuotes(swapRouteFromChainAgain.routes, this.chainId, currencyIn, currencyOut, protocols.sort(), await blockNumber, tradeType, amount.toExact());
+                        await this.setCachedRoutesAndLog(amount, currencyIn, currencyOut, tradeType, 'SetCachedRoute_NewPath', routesToCache, routingConfig.cachedRoutesRouteIds);
+                    }
+                }
+            }
+        }
+        if (!swapRouteRaw) {
+            return null;
+        }
+        const { quote, quoteGasAdjusted, estimatedGasUsed, routes: routeAmounts, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, estimatedGasUsedGasToken, } = swapRouteRaw;
+        // we intentionally dont add shouldEnableCachedRoutesCacheInvalidationFix in if condition below
+        // because we know cached routes in prod dont filter by blocks-to-live
+        // so that we know that swapRouteFromChain is always not populated, because
+        // if (!cachedRoutes || cacheMode !== CacheMode.Livemode) above always have the cachedRoutes as populated
+        if (this.routeCachingProvider &&
+            routingConfig.writeToCachedRoutes &&
+            cacheMode !== CacheMode.Darkmode &&
+            swapRouteFromChain) {
+            if (newSetCachedRoutesPath) {
+                // SetCachedRoute_NewPath and SetCachedRoute_OldPath metrics might have counts during short timeframe.
+                // over time, we should expect to see less SetCachedRoute_OldPath metrics count.
+                // in AWS metrics, one can investigate, by:
+                // 1) seeing the overall metrics count of SetCachedRoute_NewPath and SetCachedRoute_OldPath. SetCachedRoute_NewPath should steadily go up, while SetCachedRoute_OldPath should go down.
+                // 2) using the same requestId, one should see eventually when SetCachedRoute_NewPath metric is logged, SetCachedRoute_OldPath metric should not be called.
+                metric.putMetric(`SetCachedRoute_OldPath_INTENT_${routingConfig.intent}`, 1, MetricLoggerUnit.Count);
+            }
+            // Generate the object to be cached
+            const routesToCache = CachedRoutes.fromRoutesWithValidQuotes(swapRouteFromChain.routes, this.chainId, currencyIn, currencyOut, protocols.sort(), await blockNumber, tradeType, amount.toExact());
+            await this.setCachedRoutesAndLog(amount, currencyIn, currencyOut, tradeType, 'SetCachedRoute_OldPath', routesToCache, routingConfig.cachedRoutesRouteIds);
+        }
+        metric.putMetric(`QuoteFoundForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+        // Build Trade object that represents the optimal swap.
+        const trade = buildTrade(currencyIn, currencyOut, tradeType, routeAmounts);
+        let methodParameters;
+        // If user provided recipient, deadline etc. we also generate the calldata required to execute
+        // the swap and return it too.
+        if (swapConfig) {
+            methodParameters = buildSwapMethodParameters(trade, swapConfig, this.chainId);
+        }
+        const tokenOutAmount = tradeType === TradeType.EXACT_OUTPUT
+            ? originalAmount // we need to pass in originalAmount instead of amount, because amount already added portionAmount in case of exact out swap
+            : quote;
+        const portionAmount = this.portionProvider.getPortionAmount(tokenOutAmount, tradeType, feeTakenOnTransfer, externalTransferFailed, swapConfig);
+        const portionQuoteAmount = this.portionProvider.getPortionQuoteAmount(tradeType, quote, amount, // we need to pass in amount instead of originalAmount here, because amount here needs to add the portion for exact out
+        portionAmount);
+        // we need to correct quote and quote gas adjusted for exact output when portion is part of the exact out swap
+        const correctedQuote = this.portionProvider.getQuote(tradeType, quote, portionQuoteAmount);
+        const correctedQuoteGasAdjusted = this.portionProvider.getQuoteGasAdjusted(tradeType, quoteGasAdjusted, portionQuoteAmount);
+        const quoteGasAndPortionAdjusted = this.portionProvider.getQuoteGasAndPortionAdjusted(tradeType, quoteGasAdjusted, portionAmount);
+        const swapRoute = {
+            quote: correctedQuote,
+            quoteGasAdjusted: correctedQuoteGasAdjusted,
+            estimatedGasUsed,
+            estimatedGasUsedQuoteToken,
+            estimatedGasUsedUSD,
+            estimatedGasUsedGasToken,
+            gasPriceWei,
+            route: routeAmounts,
+            trade,
+            methodParameters,
+            blockNumber: BigNumber.from(await blockNumber),
+            hitsCachedRoute: hitsCachedRoute,
+            portionAmount: portionAmount,
+            quoteGasAndPortionAdjusted: quoteGasAndPortionAdjusted,
+        };
+        if (swapConfig &&
+            swapConfig.simulate &&
+            methodParameters &&
+            methodParameters.calldata) {
+            if (!this.simulator) {
+                throw new Error('Simulator not initialized!');
+            }
+            log.info(JSON.stringify({ swapConfig, methodParameters, providerConfig }, null, 2), `Starting simulation`);
+            const fromAddress = swapConfig.simulate.fromAddress;
+            const beforeSimulate = Date.now();
+            const swapRouteWithSimulation = await this.simulator.simulate(fromAddress, swapConfig, swapRoute, amount, 
+            // Quote will be in WETH even if quoteCurrency is ETH
+            // So we init a new CurrencyAmount object here
+            CurrencyAmount.fromRawAmount(quoteCurrency, quote.quotient.toString()), providerConfig);
+            if (((_0 = this.deleteCacheEnabledChains) === null || _0 === void 0 ? void 0 : _0.includes(this.chainId)) &&
+                swapRouteWithSimulation.simulationStatus === SimulationStatus.Failed) {
+                // invalidate cached route if simulation failed
+                log.info({
+                    simulationStatus: swapRouteWithSimulation.simulationStatus,
+                    swapRoute: swapRouteWithSimulation,
+                }, `Simulation failed - detailed failure information: CacheInvalidationCount_${this.chainId}`);
+                metric.putMetric(`CacheInvalidationCount_${this.chainId}`, 1, MetricLoggerUnit.Count);
+                // Generate the object to be cached
+                const routesToCache = CachedRoutes.fromRoutesWithValidQuotes(swapRouteWithSimulation.route, this.chainId, currencyIn, currencyOut, protocols.sort(), await blockNumber, tradeType, amount.toExact());
+                if (!routesToCache) {
+                    log.error({ swapRouteWithSimulation }, 'Failed to generate cached routes after simulation failure');
+                }
+                else {
+                    try {
+                        await ((_1 = this.routeCachingProvider) === null || _1 === void 0 ? void 0 : _1.deleteCachedRoute(routesToCache));
+                    }
+                    catch (err) {
+                        log.error({ err, routesToCache }, 'Failed to delete cached route after simulation failure');
+                    }
+                }
+            }
+            metric.putMetric('SimulateTransaction', Date.now() - beforeSimulate, MetricLoggerUnit.Milliseconds);
+            return swapRouteWithSimulation;
+        }
+        return swapRoute;
+    }
+    /**
+     * Refreshes the pools for the given routes.
+     *
+     * @param routes the routes to refresh the pools for
+     * @param routingConfig the routing config
+     */
+    async refreshPools(routes, routingConfig, v2PoolProvider, v3PoolProvider, v4PoolProvider) {
+        for (const route of routes) {
+            switch (route.protocol) {
+                case Protocol.V2:
+                    route.route = await AlphaRouter.refreshV2Pools(route.route, routingConfig, v2PoolProvider);
+                    break;
+                case Protocol.V3:
+                    route.route = await AlphaRouter.refreshV3Pools(route.route, routingConfig, v3PoolProvider);
+                    break;
+                case Protocol.V4:
+                    route.route = await AlphaRouter.refreshV4Pools(route.route, routingConfig, v4PoolProvider);
+                    break;
+                case Protocol.MIXED:
+                    route.route = await AlphaRouter.refreshMixedPools(route.route, routingConfig, v2PoolProvider, v3PoolProvider, v4PoolProvider);
+                    break;
+                default:
+                    throw new Error(`Unknown protocol: ${route.protocol}`);
+            }
+        }
+    }
+    /**
+     * Refreshes the V2 pools for the given route.
+     *
+     * @param route the route to refresh the V2 pools for
+     * @param config the routing config
+     * @param v2PoolProvider the V2 pool provider
+     * @returns the refreshed route
+     */
+    static async refreshV2Pools(route, config, v2PoolProvider) {
+        const refreshedPairs = [];
+        for (const pair of route.pairs) {
+            const v2Pools = await v2PoolProvider.getPools([[pair.token0, pair.token1]], config);
+            const refreshed = v2Pools.getPool(pair.token0, pair.token1);
+            if (refreshed)
+                refreshedPairs.push(refreshed);
+            else {
+                // if the pool is not found, we need to log the error and add the original pool back in
+                AlphaRouter.logV2PoolRefreshError(pair);
+                refreshedPairs.push(pair);
+            }
+        }
+        return cloneV2RouteWithNewPools(route, refreshedPairs);
+    }
+    /**
+     * Refreshes the V3 pools for the given route.
+     *
+     * @param route the route to refresh the V3 pools for
+     * @param config the routing config
+     * @param v3PoolProvider the V3 pool provider
+     * @returns the refreshed route
+     */
+    static async refreshV3Pools(route, config, v3PoolProvider) {
+        const refreshedPools = [];
+        for (const pool of route.pools) {
+            const v3Pools = await v3PoolProvider.getPools([[pool.token0, pool.token1, pool.fee]], config);
+            const refreshed = v3Pools.getPool(pool.token0, pool.token1, pool.fee);
+            if (refreshed)
+                refreshedPools.push(refreshed);
+            else {
+                // if the pool is not found, we need to log the error and add the original pool back in
+                AlphaRouter.logV3PoolRefreshError(pool);
+                refreshedPools.push(pool);
+            }
+        }
+        return cloneV3RouteWithNewPools(route, refreshedPools);
+    }
+    /**
+     * Refreshes the V4 pools for the given route.
+     *
+     * @param route the route to refresh the V4 pools for
+     * @param config the routing config
+     * @param v4PoolProvider the V4 pool provider
+     * @returns the refreshed route
+     */
+    static async refreshV4Pools(route, config, v4PoolProvider) {
+        const refreshedPools = [];
+        for (const pool of route.pools) {
+            const v4Pools = await v4PoolProvider.getPools([
+                [
+                    pool.currency0,
+                    pool.currency1,
+                    pool.fee,
+                    pool.tickSpacing,
+                    pool.hooks,
+                ],
+            ], config);
+            const refreshed = v4Pools.getPool(pool.currency0, pool.currency1, pool.fee, pool.tickSpacing, pool.hooks);
+            if (refreshed)
+                refreshedPools.push(refreshed);
+            else {
+                // if the pool is not found, we need to log the error and add the original pool back in
+                AlphaRouter.logV4PoolRefreshError(pool);
+                refreshedPools.push(pool);
+            }
+        }
+        return cloneV4RouteWithNewPools(route, refreshedPools);
+    }
+    /**
+     * Refreshes the mixed pools for the given route.
+     *
+     * @param route the route to refresh the mixed pools for
+     * @param config the routing config
+     * @param v2PoolProvider the V2 pool provider
+     * @param v3PoolProvider the V3 pool provider
+     * @param v4PoolProvider the V4 pool provider
+     * @returns the refreshed route
+     */
+    static async refreshMixedPools(route, config, v2PoolProvider, v3PoolProvider, v4PoolProvider) {
+        const refreshedPools = [];
+        for (const pool of route.pools) {
+            if (pool instanceof V2Pool) {
+                const v2Pools = await v2PoolProvider.getPools([[pool.token0, pool.token1]], config);
+                const refreshed = v2Pools.getPool(pool.token0, pool.token1);
+                if (refreshed)
+                    refreshedPools.push(refreshed);
+                else {
+                    // if the pool is not found, we need to log the error and add the original pool back in
+                    AlphaRouter.logV2PoolRefreshError(pool);
+                    refreshedPools.push(pool);
+                }
+            }
+            else if (pool instanceof V3Pool) {
+                const v3Pools = await v3PoolProvider.getPools([[pool.token0, pool.token1, pool.fee]], config);
+                const refreshed = v3Pools.getPool(pool.token0, pool.token1, pool.fee);
+                if (refreshed)
+                    refreshedPools.push(refreshed);
+                else {
+                    // if the pool is not found, we need to log the error and add the original pool back in
+                    AlphaRouter.logV3PoolRefreshError(pool);
+                    refreshedPools.push(pool);
+                }
+            }
+            else if (pool instanceof V4Pool) {
+                const v4Pools = await v4PoolProvider.getPools([
+                    [
+                        pool.currency0,
+                        pool.currency1,
+                        pool.fee,
+                        pool.tickSpacing,
+                        pool.hooks,
+                    ],
+                ], config);
+                const refreshed = v4Pools.getPool(pool.currency0, pool.currency1, pool.fee, pool.tickSpacing, pool.hooks);
+                if (refreshed)
+                    refreshedPools.push(refreshed);
+                else {
+                    // if the pool is not found, we need to log the error and add the original pool back in
+                    AlphaRouter.logV4PoolRefreshError(pool);
+                    refreshedPools.push(pool);
+                }
+            }
+            else {
+                throw new Error('Unknown pool type in mixed route');
+            }
+        }
+        return cloneMixedRouteWithNewPools(route, refreshedPools);
+    }
+    static logV2PoolRefreshError(v2Pool) {
+        log.error({
+            token0: v2Pool.token0,
+            token1: v2Pool.token1,
+        }, 'Failed to refresh V2 pool');
+    }
+    static logV3PoolRefreshError(v3Pool) {
+        log.error({
+            token0: v3Pool.token0,
+            token1: v3Pool.token1,
+            fee: v3Pool.fee,
+        }, 'Failed to refresh V3 pool');
+    }
+    static logV4PoolRefreshError(v4Pool) {
+        log.error({
+            token0: v4Pool.currency0,
+            token1: v4Pool.currency1,
+            fee: v4Pool.fee,
+            tickSpacing: v4Pool.tickSpacing,
+            hooks: v4Pool.hooks,
+        }, 'Failed to refresh V4 pool');
+    }
+    async setCachedRoutesAndLog(amount, currencyIn, currencyOut, tradeType, metricsPrefix, routesToCache, cachedRoutesRouteIds) {
+        var _a;
+        if (routesToCache) {
+            const cachedRoutesChanged = cachedRoutesRouteIds !== undefined &&
+                // it's possible that top cached routes may be split routes,
+                // so that we always serialize all the top 8 retrieved cached routes vs the top routes.
+                !cachedRoutesRouteIds.startsWith(serializeRouteIds(routesToCache.routes.map((r) => r.routeId)));
+            if (cachedRoutesChanged) {
+                metric.putMetric('cachedRoutesChanged', 1, MetricLoggerUnit.Count);
+                metric.putMetric(`cachedRoutesChanged_chainId${currencyIn.chainId}`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`cachedRoutesChanged_chainId${currencyOut.chainId}_pair${currencyIn.symbol}${currencyOut.symbol}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric('cachedRoutesNotChanged', 1, MetricLoggerUnit.Count);
+                metric.putMetric(`cachedRoutesNotChanged_chainId${currencyIn.chainId}`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`cachedRoutesNotChanged_chainId${currencyOut.chainId}_pair${currencyIn.symbol}${currencyOut.symbol}`, 1, MetricLoggerUnit.Count);
+            }
+            await ((_a = this.routeCachingProvider) === null || _a === void 0 ? void 0 : _a.setCachedRoute(routesToCache, amount).then((success) => {
+                const status = success ? 'success' : 'rejected';
+                metric.putMetric(`${metricsPrefix}_${status}`, 1, MetricLoggerUnit.Count);
+            }).catch((reason) => {
+                log.error({
+                    reason: reason,
+                    tokenPair: this.tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType),
+                }, `SetCachedRoute failure`);
+                metric.putMetric(`${metricsPrefix}_failure`, 1, MetricLoggerUnit.Count);
+            }));
+        }
+        else {
+            metric.putMetric(`${metricsPrefix}_unnecessary`, 1, MetricLoggerUnit.Count);
+        }
+    }
+    async getSwapRouteFromCache(currencyIn, currencyOut, cachedRoutes, blockNumber, amount, quoteCurrency, tradeType, routingConfig, v3GasModel, v4GasModel, mixedRouteGasModel, gasPriceWei, v2GasModel, swapConfig, providerConfig) {
+        var _a, _c, _d, _e, _f, _g;
+        const tokenPairProperties = await this.tokenPropertiesProvider.getTokensProperties([currencyIn, currencyOut], providerConfig);
+        const sellTokenIsFot = (_d = (_c = (_a = tokenPairProperties[getAddressLowerCase(currencyIn)]) === null || _a === void 0 ? void 0 : _a.tokenFeeResult) === null || _c === void 0 ? void 0 : _c.sellFeeBps) === null || _d === void 0 ? void 0 : _d.gt(0);
+        const buyTokenIsFot = (_g = (_f = (_e = tokenPairProperties[getAddressLowerCase(currencyOut)]) === null || _e === void 0 ? void 0 : _e.tokenFeeResult) === null || _f === void 0 ? void 0 : _f.buyFeeBps) === null || _g === void 0 ? void 0 : _g.gt(0);
+        const fotInDirectSwap = sellTokenIsFot || buyTokenIsFot;
+        log.info({
+            protocols: cachedRoutes.protocolsCovered,
+            tradeType: cachedRoutes.tradeType,
+            cachedBlockNumber: cachedRoutes.blockNumber,
+            quoteBlockNumber: blockNumber,
+        }, 'Routing across CachedRoute');
+        const quotePromises = [];
+        const v4Routes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.V4);
+        const v3Routes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.V3);
+        const v2Routes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.V2);
+        const mixedRoutes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.MIXED);
+        let percents;
+        let amounts;
+        if (cachedRoutes.routes.length > 1) {
+            // If we have more than 1 route, we will quote the different percents for it, following the regular process
+            [percents, amounts] = this.getAmountDistribution(amount, routingConfig);
+        }
+        else if (cachedRoutes.routes.length == 1) {
+            [percents, amounts] = [[100], [amount]];
+        }
+        else {
+            // In this case this means that there's no route, so we return null
+            return Promise.resolve(null);
+        }
+        if (v4Routes.length > 0) {
+            const v4RoutesFromCache = v4Routes.map((cachedRoute) => cachedRoute.route);
+            metric.putMetric('SwapRouteFromCache_V4_GetQuotes_Request', 1, MetricLoggerUnit.Count);
+            const beforeGetQuotes = Date.now();
+            quotePromises.push(this.v4Quoter
+                .getQuotes(v4RoutesFromCache, amounts, percents, quoteCurrency, tradeType, routingConfig, undefined, v4GasModel)
+                .then((result) => {
+                metric.putMetric(`SwapRouteFromCache_V4_GetQuotes_Load`, Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+                return result;
+            }));
+        }
+        if (!fotInDirectSwap) {
+            if (v3Routes.length > 0) {
+                const v3RoutesFromCache = v3Routes.map((cachedRoute) => cachedRoute.route);
+                metric.putMetric('SwapRouteFromCache_V3_GetQuotes_Request', 1, MetricLoggerUnit.Count);
+                const beforeGetQuotes = Date.now();
+                quotePromises.push(this.v3Quoter
+                    .getQuotes(v3RoutesFromCache, amounts, percents, quoteCurrency.wrapped, tradeType, routingConfig, undefined, v3GasModel)
+                    .then((result) => {
+                    metric.putMetric(`SwapRouteFromCache_V3_GetQuotes_Load`, Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+                    return result;
+                }));
+            }
+        }
+        if (v2Routes.length > 0) {
+            const v2RoutesFromCache = v2Routes.map((cachedRoute) => cachedRoute.route);
+            metric.putMetric('SwapRouteFromCache_V2_GetQuotes_Request', 1, MetricLoggerUnit.Count);
+            const beforeGetQuotes = Date.now();
+            quotePromises.push(this.v2Quoter
+                .refreshRoutesThenGetQuotes(cachedRoutes.currencyIn.wrapped, cachedRoutes.currencyOut.wrapped, v2RoutesFromCache, amounts, percents, quoteCurrency.wrapped, tradeType, routingConfig, gasPriceWei)
+                .then((result) => {
+                metric.putMetric(`SwapRouteFromCache_V2_GetQuotes_Load`, Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+                return result;
+            }));
+        }
+        if (!fotInDirectSwap) {
+            if (mixedRoutes.length > 0) {
+                const mixedRoutesFromCache = mixedRoutes.map((cachedRoute) => cachedRoute.route);
+                metric.putMetric('SwapRouteFromCache_Mixed_GetQuotes_Request', 1, MetricLoggerUnit.Count);
+                const beforeGetQuotes = Date.now();
+                quotePromises.push(this.mixedQuoter
+                    .getQuotes(mixedRoutesFromCache, amounts, percents, quoteCurrency.wrapped, tradeType, routingConfig, undefined, mixedRouteGasModel)
+                    .then((result) => {
+                    metric.putMetric(`SwapRouteFromCache_Mixed_GetQuotes_Load`, Date.now() - beforeGetQuotes, MetricLoggerUnit.Milliseconds);
+                    return result;
+                }));
+            }
+        }
+        const getQuotesResults = await Promise.all(quotePromises);
+        const allRoutesWithValidQuotes = _.flatMap(getQuotesResults, (quoteResult) => quoteResult.routesWithValidQuotes);
+        return getBestSwapRoute(amount, percents, allRoutesWithValidQuotes, tradeType, this.chainId, routingConfig, this.portionProvider, v2GasModel, v3GasModel, v4GasModel, swapConfig, providerConfig);
+    }
+    async getSwapRouteFromChain(amount, currencyIn, currencyOut, protocols, quoteCurrency, tradeType, routingConfig, v3GasModel, v4GasModel, mixedRouteGasModel, gasPriceWei, v2GasModel, swapConfig, providerConfig) {
+        var _a, _c, _d, _e, _f, _g, _h, _j, _k;
+        const tokenPairProperties = await this.tokenPropertiesProvider.getTokensProperties([currencyIn, currencyOut], providerConfig);
+        const sellTokenIsFot = (_d = (_c = (_a = tokenPairProperties[getAddressLowerCase(currencyIn)]) === null || _a === void 0 ? void 0 : _a.tokenFeeResult) === null || _c === void 0 ? void 0 : _c.sellFeeBps) === null || _d === void 0 ? void 0 : _d.gt(0);
+        const buyTokenIsFot = (_g = (_f = (_e = tokenPairProperties[getAddressLowerCase(currencyOut)]) === null || _e === void 0 ? void 0 : _e.tokenFeeResult) === null || _f === void 0 ? void 0 : _f.buyFeeBps) === null || _g === void 0 ? void 0 : _g.gt(0);
+        const fotInDirectSwap = sellTokenIsFot || buyTokenIsFot;
+        // Generate our distribution of amounts, i.e. fractions of the input amount.
+        // We will get quotes for fractions of the input amount for different routes, then
+        // combine to generate split routes.
+        const [percents, amounts] = this.getAmountDistribution(amount, routingConfig);
+        const noProtocolsSpecified = protocols.length === 0;
+        const v4ProtocolSpecified = protocols.includes(Protocol.V4);
+        const v3ProtocolSpecified = protocols.includes(Protocol.V3);
+        const v2ProtocolSpecified = protocols.includes(Protocol.V2);
+        const v2SupportedInChain = (_h = this.v2Supported) === null || _h === void 0 ? void 0 : _h.includes(this.chainId);
+        const v4SupportedInChain = (_j = this.v4Supported) === null || _j === void 0 ? void 0 : _j.includes(this.chainId);
+        const shouldQueryMixedProtocol = protocols.includes(Protocol.MIXED) ||
+            (noProtocolsSpecified && v2SupportedInChain && v4SupportedInChain);
+        const mixedProtocolAllowed = ((_k = this.mixedSupported) === null || _k === void 0 ? void 0 : _k.includes(this.chainId)) &&
+            tradeType === TradeType.EXACT_INPUT;
+        const beforeGetCandidates = Date.now();
+        let v4CandidatePoolsPromise = Promise.resolve(undefined);
+        // we are explicitly requiring people to specify v4 for now
+        if (v4SupportedInChain && (v4ProtocolSpecified || noProtocolsSpecified)) {
+            // if (v4ProtocolSpecified || noProtocolsSpecified) {
+            v4CandidatePoolsPromise = getV4CandidatePools({
+                currencyIn: currencyIn,
+                currencyOut: currencyOut,
+                tokenProvider: this.tokenProvider,
+                blockedTokenListProvider: this.blockedTokenListProvider,
+                poolProvider: this.v4PoolProvider,
+                routeType: tradeType,
+                subgraphProvider: this.v4SubgraphProvider,
+                routingConfig,
+                chainId: this.chainId,
+                v4PoolParams: this.v4PoolParams,
+            }).then((candidatePools) => {
+                metric.putMetric('GetV4CandidatePools', Date.now() - beforeGetCandidates, MetricLoggerUnit.Milliseconds);
+                return candidatePools;
+            });
+        }
+        let v3CandidatePoolsPromise = Promise.resolve(undefined);
+        if (!fotInDirectSwap) {
+            if (v3ProtocolSpecified || noProtocolsSpecified) {
+                const tokenIn = currencyIn.wrapped;
+                const tokenOut = currencyOut.wrapped;
+                v3CandidatePoolsPromise = getV3CandidatePools({
+                    tokenIn,
+                    tokenOut,
+                    tokenProvider: this.tokenProvider,
+                    blockedTokenListProvider: this.blockedTokenListProvider,
+                    poolProvider: this.v3PoolProvider,
+                    routeType: tradeType,
+                    subgraphProvider: this.v3SubgraphProvider,
+                    routingConfig,
+                    chainId: this.chainId,
+                }).then((candidatePools) => {
+                    metric.putMetric('GetV3CandidatePools', Date.now() - beforeGetCandidates, MetricLoggerUnit.Milliseconds);
+                    return candidatePools;
+                });
+            }
+        }
+        let v2CandidatePoolsPromise = Promise.resolve(undefined);
+        if (v2SupportedInChain && (v2ProtocolSpecified || noProtocolsSpecified)) {
+            const tokenIn = currencyIn.wrapped;
+            const tokenOut = currencyOut.wrapped;
+            // 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.
+            v2CandidatePoolsPromise = getV2CandidatePools({
+                tokenIn,
+                tokenOut,
+                tokenProvider: this.tokenProvider,
+                blockedTokenListProvider: this.blockedTokenListProvider,
+                poolProvider: this.v2PoolProvider,
+                routeType: tradeType,
+                subgraphProvider: this.v2SubgraphProvider,
+                routingConfig,
+                chainId: this.chainId,
+            }).then((candidatePools) => {
+                metric.putMetric('GetV2CandidatePools', Date.now() - beforeGetCandidates, MetricLoggerUnit.Milliseconds);
+                return candidatePools;
+            });
+        }
+        const quotePromises = [];
+        // for v4, for now we explicitly require people to specify
+        if (v4SupportedInChain && v4ProtocolSpecified) {
+            log.info({ protocols, tradeType }, 'Routing across V4');
+            metric.putMetric('SwapRouteFromChain_V4_GetRoutesThenQuotes_Request', 1, MetricLoggerUnit.Count);
+            const beforeGetRoutesThenQuotes = Date.now();
+            quotePromises.push(v4CandidatePoolsPromise.then((v4CandidatePools) => this.v4Quoter
+                .getRoutesThenQuotes(currencyIn, currencyOut, amount, amounts, percents, quoteCurrency, v4CandidatePools, tradeType, routingConfig, v4GasModel)
+                .then((result) => {
+                metric.putMetric(`SwapRouteFromChain_V4_GetRoutesThenQuotes_Load`, Date.now() - beforeGetRoutesThenQuotes, MetricLoggerUnit.Milliseconds);
+                return result;
+            })));
+        }
+        if (!fotInDirectSwap) {
+            // Maybe Quote V3 - if V3 is specified, or no protocol is specified
+            if (v3ProtocolSpecified || noProtocolsSpecified) {
+                log.info({ protocols, tradeType }, 'Routing across V3');
+                metric.putMetric('SwapRouteFromChain_V3_GetRoutesThenQuotes_Request', 1, MetricLoggerUnit.Count);
+                const beforeGetRoutesThenQuotes = Date.now();
+                const tokenIn = currencyIn.wrapped;
+                const tokenOut = currencyOut.wrapped;
+                quotePromises.push(v3CandidatePoolsPromise.then((v3CandidatePools) => this.v3Quoter
+                    .getRoutesThenQuotes(tokenIn, tokenOut, amount, amounts, percents, quoteCurrency.wrapped, v3CandidatePools, tradeType, routingConfig, v3GasModel)
+                    .then((result) => {
+                    metric.putMetric(`SwapRouteFromChain_V3_GetRoutesThenQuotes_Load`, Date.now() - beforeGetRoutesThenQuotes, MetricLoggerUnit.Milliseconds);
+                    return result;
+                })));
+            }
+        }
+        // Maybe Quote V2 - if V2 is specified, or no protocol is specified AND v2 is supported in this chain
+        if (v2SupportedInChain && (v2ProtocolSpecified || noProtocolsSpecified)) {
+            log.info({ protocols, tradeType }, 'Routing across V2');
+            metric.putMetric('SwapRouteFromChain_V2_GetRoutesThenQuotes_Request', 1, MetricLoggerUnit.Count);
+            const beforeGetRoutesThenQuotes = Date.now();
+            const tokenIn = currencyIn.wrapped;
+            const tokenOut = currencyOut.wrapped;
+            quotePromises.push(v2CandidatePoolsPromise.then((v2CandidatePools) => this.v2Quoter
+                .getRoutesThenQuotes(tokenIn, tokenOut, amount, amounts, percents, quoteCurrency.wrapped, v2CandidatePools, tradeType, routingConfig, v2GasModel, gasPriceWei)
+                .then((result) => {
+                metric.putMetric(`SwapRouteFromChain_V2_GetRoutesThenQuotes_Load`, Date.now() - beforeGetRoutesThenQuotes, MetricLoggerUnit.Milliseconds);
+                return result;
+            })));
+        }
+        if (!fotInDirectSwap) {
+            // Maybe Quote mixed routes
+            // if MixedProtocol is specified or no protocol is specified and v2 is supported AND tradeType is ExactIn
+            // AND is Mainnet or Gorli
+            // Also make sure there are at least 2 protocols provided besides MIXED, before entering mixed quoter
+            if (shouldQueryMixedProtocol &&
+                mixedProtocolAllowed &&
+                protocols.filter((protocol) => protocol !== Protocol.MIXED).length >= 2) {
+                log.info({ protocols, tradeType }, 'Routing across MixedRoutes');
+                metric.putMetric('SwapRouteFromChain_Mixed_GetRoutesThenQuotes_Request', 1, MetricLoggerUnit.Count);
+                const beforeGetRoutesThenQuotes = Date.now();
+                quotePromises.push(Promise.all([
+                    v4CandidatePoolsPromise,
+                    v3CandidatePoolsPromise,
+                    v2CandidatePoolsPromise,
+                ]).then(async ([v4CandidatePools, v3CandidatePools, v2CandidatePools]) => {
+                    const tokenIn = currencyIn.wrapped;
+                    const tokenOut = currencyOut.wrapped;
+                    const crossLiquidityPools = await getMixedCrossLiquidityCandidatePools({
+                        tokenIn,
+                        tokenOut,
+                        blockNumber: routingConfig.blockNumber,
+                        v2SubgraphProvider: this.v2SubgraphProvider,
+                        v3SubgraphProvider: this.v3SubgraphProvider,
+                        v4SubgraphProvider: this.v4SubgraphProvider,
+                        v2Candidates: v2CandidatePools,
+                        v3Candidates: v3CandidatePools,
+                        v4Candidates: v4CandidatePools,
+                        mixedCrossLiquidityV3AgainstV4Supported: this.mixedCrossLiquidityV3AgainstV4Supported,
+                        chainId: this.chainId,
+                    });
+                    return this.mixedQuoter
+                        .getRoutesThenQuotes(currencyIn, currencyOut, amount, amounts, percents, quoteCurrency.wrapped, [
+                        v4CandidatePools,
+                        v3CandidatePools,
+                        v2CandidatePools,
+                        crossLiquidityPools,
+                    ], tradeType, routingConfig, mixedRouteGasModel)
+                        .then((result) => {
+                        metric.putMetric(`SwapRouteFromChain_Mixed_GetRoutesThenQuotes_Load`, Date.now() - beforeGetRoutesThenQuotes, MetricLoggerUnit.Milliseconds);
+                        return result;
+                    });
+                }));
+            }
+        }
+        const getQuotesResults = await Promise.all(quotePromises);
+        const allRoutesWithValidQuotes = [];
+        const allCandidatePools = [];
+        getQuotesResults.forEach((getQuoteResult) => {
+            allRoutesWithValidQuotes.push(...getQuoteResult.routesWithValidQuotes);
+            if (getQuoteResult.candidatePools) {
+                allCandidatePools.push(getQuoteResult.candidatePools);
+            }
+        });
+        if (allRoutesWithValidQuotes.length === 0) {
+            log.info({ allRoutesWithValidQuotes }, 'Received no valid quotes');
+            return null;
+        }
+        // Given all the quotes for all the amounts for all the routes, find the best combination.
+        const bestSwapRoute = await getBestSwapRoute(amount, percents, allRoutesWithValidQuotes, tradeType, this.chainId, routingConfig, this.portionProvider, v2GasModel, v3GasModel, v4GasModel, swapConfig, providerConfig);
+        if (bestSwapRoute) {
+            this.emitPoolSelectionMetrics(bestSwapRoute, allCandidatePools, currencyIn, currencyOut);
+        }
+        return bestSwapRoute;
+    }
+    tradeTypeStr(tradeType) {
+        return tradeType === TradeType.EXACT_INPUT ? 'ExactIn' : 'ExactOut';
+    }
+    tokenPairSymbolTradeTypeChainId(currencyIn, currencyOut, tradeType) {
+        return `${currencyIn.symbol}/${currencyOut.symbol}/${this.tradeTypeStr(tradeType)}/${this.chainId}`;
+    }
+    determineCurrencyInOutFromTradeType(tradeType, amount, quoteCurrency) {
+        if (tradeType === TradeType.EXACT_INPUT) {
+            return {
+                currencyIn: amount.currency,
+                currencyOut: quoteCurrency,
+            };
+        }
+        else {
+            return {
+                currencyIn: quoteCurrency,
+                currencyOut: amount.currency,
+            };
+        }
+    }
+    async getGasPriceWei(latestBlockNumber, requestBlockNumber) {
+        // Track how long it takes to resolve this async call.
+        const beforeGasTimestamp = Date.now();
+        // Get an estimate of the gas price to use when estimating gas cost of different routes.
+        const { gasPriceWei } = await this.gasPriceProvider.getGasPrice(latestBlockNumber, requestBlockNumber);
+        metric.putMetric('GasPriceLoad', Date.now() - beforeGasTimestamp, MetricLoggerUnit.Milliseconds);
+        return gasPriceWei;
+    }
+    async getGasModels(gasPriceWei, amountToken, quoteToken, providerConfig) {
+        var _a;
+        const beforeGasModel = Date.now();
+        const usdPoolPromise = getHighestLiquidityV3USDPool(this.chainId, this.v3PoolProvider, providerConfig);
+        const nativeCurrency = WRAPPED_NATIVE_CURRENCY[this.chainId];
+        const nativeAndQuoteTokenV3PoolPromise = !quoteToken.equals(nativeCurrency)
+            ? getHighestLiquidityV3NativePool(quoteToken, this.v3PoolProvider, providerConfig)
+            : Promise.resolve(null);
+        const nativeAndAmountTokenV3PoolPromise = !amountToken.equals(nativeCurrency)
+            ? getHighestLiquidityV3NativePool(amountToken, this.v3PoolProvider, providerConfig)
+            : Promise.resolve(null);
+        // If a specific gas token is specified in the provider config
+        // fetch the highest liq V3 pool with it and the native currency
+        const nativeAndSpecifiedGasTokenV3PoolPromise = (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.gasToken) &&
+            !(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.gasToken.equals(nativeCurrency))
+            ? getHighestLiquidityV3NativePool(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.gasToken, this.v3PoolProvider, providerConfig)
+            : Promise.resolve(null);
+        const [usdPool, nativeAndQuoteTokenV3Pool, nativeAndAmountTokenV3Pool, nativeAndSpecifiedGasTokenV3Pool,] = await Promise.all([
+            usdPoolPromise,
+            nativeAndQuoteTokenV3PoolPromise,
+            nativeAndAmountTokenV3PoolPromise,
+            nativeAndSpecifiedGasTokenV3PoolPromise,
+        ]);
+        const pools = {
+            usdPool: usdPool,
+            nativeAndQuoteTokenV3Pool: nativeAndQuoteTokenV3Pool,
+            nativeAndAmountTokenV3Pool: nativeAndAmountTokenV3Pool,
+            nativeAndSpecifiedGasTokenV3Pool: nativeAndSpecifiedGasTokenV3Pool,
+        };
+        const v2GasModelPromise = ((_a = this.v2Supported) === null || _a === void 0 ? void 0 : _a.includes(this.chainId))
+            ? this.v2GasModelFactory
+                .buildGasModel({
+                chainId: this.chainId,
+                gasPriceWei,
+                poolProvider: this.v2PoolProvider,
+                token: quoteToken,
+                l2GasDataProvider: this.l2GasDataProvider,
+                providerConfig: providerConfig,
+            })
+                .catch((_) => undefined) // If v2 model throws uncaught exception, we return undefined v2 gas model, so there's a chance v3 route can go through
+            : Promise.resolve(undefined);
+        const v3GasModelPromise = this.v3GasModelFactory.buildGasModel({
+            chainId: this.chainId,
+            gasPriceWei,
+            pools,
+            amountToken,
+            quoteToken,
+            v2poolProvider: this.v2PoolProvider,
+            l2GasDataProvider: this.l2GasDataProvider,
+            providerConfig: providerConfig,
+        });
+        const v4GasModelPromise = this.v4GasModelFactory.buildGasModel({
+            chainId: this.chainId,
+            gasPriceWei,
+            pools,
+            amountToken,
+            quoteToken,
+            v2poolProvider: this.v2PoolProvider,
+            l2GasDataProvider: this.l2GasDataProvider,
+            providerConfig: providerConfig,
+        });
+        const mixedRouteGasModelPromise = this.mixedRouteGasModelFactory.buildGasModel({
+            chainId: this.chainId,
+            gasPriceWei,
+            pools,
+            amountToken,
+            quoteToken,
+            v2poolProvider: this.v2PoolProvider,
+            providerConfig: providerConfig,
+        });
+        const [v2GasModel, v3GasModel, V4GasModel, mixedRouteGasModel] = await Promise.all([
+            v2GasModelPromise,
+            v3GasModelPromise,
+            v4GasModelPromise,
+            mixedRouteGasModelPromise,
+        ]);
+        metric.putMetric('GasModelCreation', Date.now() - beforeGasModel, MetricLoggerUnit.Milliseconds);
+        return {
+            v2GasModel: v2GasModel,
+            v3GasModel: v3GasModel,
+            v4GasModel: V4GasModel,
+            mixedRouteGasModel: mixedRouteGasModel,
+        };
+    }
+    // Note multiplications here can result in a loss of precision in the amounts (e.g. taking 50% of 101)
+    // This is reconcilled at the end of the algorithm by adding any lost precision to one of
+    // the splits in the route.
+    getAmountDistribution(amount, routingConfig) {
+        const { distributionPercent } = routingConfig;
+        const percents = [];
+        const amounts = [];
+        for (let i = 1; i <= 100 / distributionPercent; i++) {
+            percents.push(i * distributionPercent);
+            amounts.push(amount.multiply(new Fraction(i * distributionPercent, 100)));
+        }
+        return [percents, amounts];
+    }
+    async buildSwapAndAddMethodParameters(trade, swapAndAddOptions, swapAndAddParameters) {
+        const { swapOptions: { recipient, slippageTolerance, deadline, inputTokenPermit }, addLiquidityOptions: addLiquidityConfig, } = swapAndAddOptions;
+        const preLiquidityPosition = swapAndAddParameters.preLiquidityPosition;
+        const finalBalanceTokenIn = swapAndAddParameters.initialBalanceTokenIn.subtract(trade.inputAmount);
+        const finalBalanceTokenOut = swapAndAddParameters.initialBalanceTokenOut.add(trade.outputAmount);
+        const approvalTypes = await this.swapRouterProvider.getApprovalType(finalBalanceTokenIn, finalBalanceTokenOut);
+        const zeroForOne = finalBalanceTokenIn.currency.wrapped.sortsBefore(finalBalanceTokenOut.currency.wrapped);
+        return {
+            ...SwapRouter.swapAndAddCallParameters(trade, {
+                recipient,
+                slippageTolerance,
+                deadlineOrPreviousBlockhash: deadline,
+                inputTokenPermit,
+            }, Position.fromAmounts({
+                pool: preLiquidityPosition.pool,
+                tickLower: preLiquidityPosition.tickLower,
+                tickUpper: preLiquidityPosition.tickUpper,
+                amount0: zeroForOne
+                    ? finalBalanceTokenIn.quotient.toString()
+                    : finalBalanceTokenOut.quotient.toString(),
+                amount1: zeroForOne
+                    ? finalBalanceTokenOut.quotient.toString()
+                    : finalBalanceTokenIn.quotient.toString(),
+                useFullPrecision: false,
+            }), addLiquidityConfig, approvalTypes.approvalTokenIn, approvalTypes.approvalTokenOut),
+            to: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+        };
+    }
+    emitPoolSelectionMetrics(swapRouteRaw, allPoolsBySelection, currencyIn, currencyOut) {
+        const poolAddressesUsed = new Set();
+        const { routes: routeAmounts } = swapRouteRaw;
+        _(routeAmounts)
+            .flatMap((routeAmount) => {
+            const { poolIdentifiers: poolAddresses } = routeAmount;
+            return poolAddresses;
+        })
+            .forEach((address) => {
+            poolAddressesUsed.add(address.toLowerCase());
+        });
+        for (const poolsBySelection of allPoolsBySelection) {
+            const { protocol } = poolsBySelection;
+            _.forIn(poolsBySelection.selections, (pools, topNSelection) => {
+                const topNUsed = _.findLastIndex(pools, (pool) => poolAddressesUsed.has(pool.id.toLowerCase())) + 1;
+                metric.putMetric(_.capitalize(`${protocol}${topNSelection}`), topNUsed, MetricLoggerUnit.Count);
+            });
+        }
+        let hasV4Route = false;
+        let hasV3Route = false;
+        let hasV2Route = false;
+        let hasMixedRoute = false;
+        for (const routeAmount of routeAmounts) {
+            if (routeAmount.protocol === Protocol.V4) {
+                hasV4Route = true;
+            }
+            if (routeAmount.protocol === Protocol.V3) {
+                hasV3Route = true;
+            }
+            if (routeAmount.protocol === Protocol.V2) {
+                hasV2Route = true;
+            }
+            if (routeAmount.protocol === Protocol.MIXED) {
+                hasMixedRoute = true;
+            }
+        }
+        if (hasMixedRoute && (hasV4Route || hasV3Route || hasV2Route)) {
+            let metricsPrefix = 'Mixed';
+            if (hasV4Route) {
+                metricsPrefix += 'AndV4';
+            }
+            if (hasV3Route) {
+                metricsPrefix += 'AndV3';
+            }
+            if (hasV2Route) {
+                metricsPrefix += 'AndV2';
+            }
+            metric.putMetric(`${metricsPrefix}SplitRoute`, 1, MetricLoggerUnit.Count);
+            metric.putMetric(`${metricsPrefix}SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            if (hasV4Route && (currencyIn.isNative || currencyOut.isNative)) {
+                // Keep track of this edge case https://linear.app/uniswap/issue/ROUTE-303/tech-debt-split-route-can-have-different-ethweth-input-or-output#comment-bba53758
+                metric.putMetric(`${metricsPrefix}SplitRouteWithNativeToken`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`${metricsPrefix}SplitRouteWithNativeTokenForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV4Route && hasV3Route && hasV2Route) {
+            metric.putMetric(`V4AndV3AndV2SplitRoute`, 1, MetricLoggerUnit.Count);
+            metric.putMetric(`V4AndV3AndV2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            if (currencyIn.isNative || currencyOut.isNative) {
+                // Keep track of this edge case https://linear.app/uniswap/issue/ROUTE-303/tech-debt-split-route-can-have-different-ethweth-input-or-output#comment-bba53758
+                metric.putMetric(`V4AndV3AndV2SplitRouteWithNativeToken`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V4AndV3AndV2SplitRouteWithNativeTokenForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasMixedRoute) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`MixedSplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedSplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`MixedRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV4Route) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`V4SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V4SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV3Route) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`V3SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V3SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`V3Route`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V3RouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV2Route) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`V2SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`V2Route`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V2RouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+    }
+    calculateOptimalRatio(position, sqrtRatioX96, zeroForOne) {
+        const upperSqrtRatioX96 = TickMath.getSqrtRatioAtTick(position.tickUpper);
+        const lowerSqrtRatioX96 = TickMath.getSqrtRatioAtTick(position.tickLower);
+        // returns Fraction(0, 1) for any out of range position regardless of zeroForOne. Implication: function
+        // cannot be used to determine the trading direction of out of range positions.
+        if (JSBI.greaterThan(sqrtRatioX96, upperSqrtRatioX96) ||
+            JSBI.lessThan(sqrtRatioX96, lowerSqrtRatioX96)) {
+            return new Fraction(0, 1);
+        }
+        const precision = JSBI.BigInt('1' + '0'.repeat(18));
+        let optimalRatio = new Fraction(SqrtPriceMath.getAmount0Delta(sqrtRatioX96, upperSqrtRatioX96, precision, true), SqrtPriceMath.getAmount1Delta(sqrtRatioX96, lowerSqrtRatioX96, precision, true));
+        if (!zeroForOne)
+            optimalRatio = optimalRatio.invert();
+        return optimalRatio;
+    }
+    async userHasSufficientBalance(fromAddress, tradeType, amount, quote) {
+        try {
+            const neededBalance = tradeType === TradeType.EXACT_INPUT ? amount : quote;
+            let balance;
+            if (neededBalance.currency.isNative) {
+                balance = await this.provider.getBalance(fromAddress);
+            }
+            else {
+                const tokenContract = Erc20__factory.connect(neededBalance.currency.address, this.provider);
+                balance = await tokenContract.balanceOf(fromAddress);
+            }
+            return balance.gte(BigNumber.from(neededBalance.quotient.toString()));
+        }
+        catch (e) {
+            log.error(e, 'Error while checking user balance');
+            return false;
+        }
+    }
+    absoluteValue(fraction) {
+        const numeratorAbs = JSBI.lessThan(fraction.numerator, JSBI.BigInt(0))
+            ? JSBI.unaryMinus(fraction.numerator)
+            : fraction.numerator;
+        const denominatorAbs = JSBI.lessThan(fraction.denominator, JSBI.BigInt(0))
+            ? JSBI.unaryMinus(fraction.denominator)
+            : fraction.denominator;
+        return new Fraction(numeratorAbs, denominatorAbs);
+    }
+    getBlockNumberPromise() {
+        return retry(async (_b, attempt) => {
+            if (attempt > 1) {
+                log.info(`Get block number attempt ${attempt}`);
+            }
+            return this.provider.getBlockNumber();
+        }, {
+            retries: 2,
+            minTimeout: 100,
+            maxTimeout: 1000,
+        });
+    }
+    // If we are requesting URv1.2, we need to keep entering cache
+    // We want to skip cached routes access whenever "intent === INTENT.CACHING" or "hooksOption !== HooksOption.HOOKS_INCLUSIVE"
+    // We keep this method as we might want to add more conditions in the future.
+    static isAllowedToEnterCachedRoutes(intent, hooksOptions, swapRouter) {
+        // intent takes highest precedence, as we need to ensure during caching intent, we do not enter cache no matter what
+        if (intent !== undefined && intent === INTENT.CACHING) {
+            return false;
+        }
+        // in case we have URv1.2 request during QUOTE intent, we assume cached routes correctly returns mixed route w/o v4, if mixed is best
+        // or v2/v3 is the best.
+        // implicitly it means hooksOptions no longer matters for URv1.2
+        // swapRouter has higher precedence than hooksOptions, because in case of URv1.2, we set hooksOptions = NO_HOOKS as default,
+        // but swapRouter does not have any v4 pool for routing, so swapRouter should always use caching during QUOTE intent.
+        if (swapRouter) {
+            return true;
+        }
+        // in case we have URv2.0, and we are in QUOTE intent, we only want to enter cache when hooksOptions is default, HOOKS_INCLUSIVE
+        if (hooksOptions !== undefined &&
+            hooksOptions !== HooksOptions.HOOKS_INCLUSIVE) {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alpha-router.js","sourceRoot":"","sources":["../../../../src/routers/alpha-router/alpha-router.ts"],"names":[],"mappings":"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"}