@kumbaya_xyz/smart-order-router 4.22.38

package/build/module/providers/on-chain-quote-provider.js

@@ -0,0 +1,707 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ADDRESS_ZERO, encodeMixedRouteToPath, MixedRouteSDK, Protocol, } from '@uniswap/router-sdk';
+import { ChainId } from '@uniswap/sdk-core';
+import { encodeRouteToPath as encodeV3RouteToPath } from '@uniswap/v3-sdk';
+import { encodeRouteToPath as encodeV4RouteToPath, Pool as V4Pool, } from '@uniswap/v4-sdk';
+import retry from 'async-retry';
+import _ from 'lodash';
+import stats from 'stats-lite';
+import { V2Route, } from '../routers/router';
+import { IMixedRouteQuoterV1__factory } from '../types/other/factories/IMixedRouteQuoterV1__factory';
+import { MixedRouteQuoterV2__factory } from '../types/other/factories/MixedRouteQuoterV2__factory';
+import { V4Quoter__factory } from '../types/other/factories/V4Quoter__factory';
+import { IQuoterV2__factory } from '../types/v3/factories/IQuoterV2__factory';
+import { getAddress, ID_TO_NETWORK_NAME, metric, MetricLoggerUnit, MIXED_ROUTE_QUOTER_V1_ADDRESSES, MIXED_ROUTE_QUOTER_V2_ADDRESSES, NEW_QUOTER_V2_ADDRESSES, PROTOCOL_V4_QUOTER_ADDRESSES, } from '../util';
+import { log } from '../util/log';
+import { DEFAULT_BLOCK_NUMBER_CONFIGS, DEFAULT_SUCCESS_RATE_FAILURE_OVERRIDES, } from '../util/onchainQuoteProviderConfigs';
+import { routeToString } from '../util/routes';
+export class BlockConflictError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BlockConflictError';
+    }
+}
+export class SuccessRateError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'SuccessRateError';
+    }
+}
+export class ProviderBlockHeaderError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'ProviderBlockHeaderError';
+    }
+}
+export class ProviderTimeoutError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'ProviderTimeoutError';
+    }
+}
+/**
+ * This error typically means that the gas used by the multicall has
+ * exceeded the total call gas limit set by the node provider.
+ *
+ * This can be resolved by modifying BatchParams to request fewer
+ * quotes per call, or to set a lower gas limit per quote.
+ *
+ * @export
+ * @class ProviderGasError
+ */
+export class ProviderGasError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'ProviderGasError';
+    }
+}
+const DEFAULT_BATCH_RETRIES = 2;
+/**
+ * Computes on chain quotes for swaps. For pure V3 routes, quotes are computed on-chain using
+ * the 'QuoterV2' smart contract. For exactIn mixed and V2 routes, quotes are computed using the 'MixedRouteQuoterV1' contract
+ * This is because computing quotes off-chain would require fetching all the tick data for each pool, which is a lot of data.
+ *
+ * To minimize the number of requests for quotes we use a Multicall contract. Generally
+ * the number of quotes to fetch exceeds the maximum we can fit in a single multicall
+ * while staying under gas limits, so we also batch these quotes across multiple multicalls.
+ *
+ * The biggest challenge with the quote provider is dealing with various gas limits.
+ * Each provider sets a limit on the amount of gas a call can consume (on Infura this
+ * is approximately 10x the block max size), so we must ensure each multicall does not
+ * exceed this limit. Additionally, each quote on V3 can consume a large number of gas if
+ * the pool lacks liquidity and the swap would cause all the ticks to be traversed.
+ *
+ * To ensure we don't exceed the node's call limit, we limit the gas used by each quote to
+ * a specific value, and we limit the number of quotes in each multicall request. Users of this
+ * class should set BatchParams such that multicallChunk * gasLimitPerCall is less than their node
+ * providers total gas limit per call.
+ *
+ * @export
+ * @class OnChainQuoteProvider
+ */
+export class OnChainQuoteProvider {
+    /**
+     * Creates an instance of OnChainQuoteProvider.
+     *
+     * @param chainId The chain to get quotes for.
+     * @param provider The web 3 provider.
+     * @param multicall2Provider The multicall provider to use to get the quotes on-chain.
+     * Only supports the Uniswap Multicall contract as it needs the gas limitting functionality.
+     * @param retryOptions The retry options for each call to the multicall.
+     * @param batchParams The parameters for each batched call to the multicall.
+     * @param gasErrorFailureOverride The gas and chunk parameters to use when retrying a batch that failed due to out of gas.
+     * @param successRateFailureOverrides The parameters for retries when we fail to get quotes.
+     * @param blockNumberConfig Parameters for adjusting which block we get quotes from, and how to handle block header not found errors.
+     * @param [quoterAddressOverride] Overrides the address of the quoter contract to use.
+     * @param metricsPrefix metrics prefix to differentiate between different instances of the quote provider.
+     */
+    constructor(chainId, provider, 
+    // Only supports Uniswap Multicall as it needs the gas limitting functionality.
+    multicall2Provider, 
+    // retryOptions, batchParams, and gasErrorFailureOverride are always override in alpha-router
+    // so below default values are always not going to be picked up in prod.
+    // So we will not extract out below default values into constants.
+    retryOptions = {
+        retries: DEFAULT_BATCH_RETRIES,
+        minTimeout: 25,
+        maxTimeout: 250,
+    }, batchParams = (_optimisticCachedRoutes, _protocol) => {
+        return {
+            multicallChunk: 150,
+            gasLimitPerCall: 1000000,
+            quoteMinSuccessRate: 0.2,
+        };
+    }, gasErrorFailureOverride = (_protocol) => {
+        return {
+            gasLimitOverride: 1500000,
+            multicallChunk: 100,
+        };
+    }, 
+    // successRateFailureOverrides and blockNumberConfig are not always override in alpha-router.
+    // So we will extract out below default values into constants.
+    // In alpha-router default case, we will also define the constants with same values as below.
+    successRateFailureOverrides = (_protocol) => {
+        return DEFAULT_SUCCESS_RATE_FAILURE_OVERRIDES;
+    }, blockNumberConfig = (_protocol) => {
+        return DEFAULT_BLOCK_NUMBER_CONFIGS;
+    }, quoterAddressOverride, metricsPrefix = (chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes) => useMixedRouteQuoter
+        ? `ChainId_${chainId}_${protocol}RouteQuoter${mixedRouteContainsV4Pool ? 'V2' : 'V1'}_OptimisticCachedRoutes${optimisticCachedRoutes}_`
+        : `ChainId_${chainId}_${protocol}Quoter_OptimisticCachedRoutes${optimisticCachedRoutes}_`) {
+        this.chainId = chainId;
+        this.provider = provider;
+        this.multicall2Provider = multicall2Provider;
+        this.retryOptions = retryOptions;
+        this.batchParams = batchParams;
+        this.gasErrorFailureOverride = gasErrorFailureOverride;
+        this.successRateFailureOverrides = successRateFailureOverrides;
+        this.blockNumberConfig = blockNumberConfig;
+        this.quoterAddressOverride = quoterAddressOverride;
+        this.metricsPrefix = metricsPrefix;
+    }
+    getQuoterAddress(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol) {
+        if (this.quoterAddressOverride) {
+            const quoterAddress = this.quoterAddressOverride(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol);
+            if (!quoterAddress) {
+                throw new Error(`No address for the quoter contract on chain id: ${this.chainId} ${useMixedRouteQuoter} ${mixedRouteContainsV4Pool} ${protocol}`);
+            }
+            return quoterAddress;
+        }
+        const quoterAddress = useMixedRouteQuoter
+            ? mixedRouteContainsV4Pool
+                ? MIXED_ROUTE_QUOTER_V2_ADDRESSES[this.chainId]
+                : MIXED_ROUTE_QUOTER_V1_ADDRESSES[this.chainId]
+            : protocol === Protocol.V3
+                ? NEW_QUOTER_V2_ADDRESSES[this.chainId]
+                : PROTOCOL_V4_QUOTER_ADDRESSES[this.chainId];
+        if (!quoterAddress) {
+            throw new Error(`No address for the quoter contract on chain id: ${this.chainId}`);
+        }
+        return quoterAddress;
+    }
+    async getQuotesManyExactIn(amountIns, routes, providerConfig) {
+        return this.getQuotesManyData(amountIns, routes, 'quoteExactInput', providerConfig);
+    }
+    async getQuotesManyExactOut(amountOuts, routes, providerConfig) {
+        return this.getQuotesManyData(amountOuts, routes, 'quoteExactOutput', providerConfig);
+    }
+    encodeRouteToPath(route, functionName, mixedRouteContainsV4Pool) {
+        switch (route.protocol) {
+            case Protocol.V3:
+                return encodeV3RouteToPath(route, functionName == 'quoteExactOutput' // For exactOut must be true to ensure the routes are reversed.
+                );
+            case Protocol.V4:
+                return encodeV4RouteToPath(route, functionName == 'quoteExactOutput');
+            // We don't have onchain V2 quoter, but we do have a mixed quoter that can quote against v2 routes onchain
+            // Hence in case of V2 or mixed, we explicitly encode into mixed routes.
+            case Protocol.V2:
+            case Protocol.MIXED:
+                // we need to retain the fake pool data for the mixed route
+                return encodeMixedRouteToPath(route instanceof V2Route
+                    ? new MixedRouteSDK(route.pairs, route.input, route.output, true)
+                    : route, mixedRouteContainsV4Pool);
+            default:
+                throw new Error(`Unsupported protocol for the route: ${JSON.stringify(route)}`);
+        }
+    }
+    getContractInterface(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol) {
+        if (useMixedRouteQuoter) {
+            if (mixedRouteContainsV4Pool) {
+                return MixedRouteQuoterV2__factory.createInterface();
+            }
+            else {
+                return IMixedRouteQuoterV1__factory.createInterface();
+            }
+        }
+        switch (protocol) {
+            case Protocol.V3:
+                return IQuoterV2__factory.createInterface();
+            case Protocol.V4:
+                return V4Quoter__factory.createInterface();
+            default:
+                throw new Error(`Unsupported protocol: ${protocol}`);
+        }
+    }
+    async consolidateResults(protocol, useMixedRouteQuoter, mixedRouteContainsV4Pool, functionName, inputs, providerConfig, gasLimitOverride) {
+        if ((protocol === Protocol.MIXED && mixedRouteContainsV4Pool) ||
+            protocol === Protocol.V4) {
+            const mixedQuote = await this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+                address: this.getQuoterAddress(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol),
+                contractInterface: this.getContractInterface(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol),
+                functionName,
+                functionParams: inputs,
+                providerConfig,
+                additionalConfig: {
+                    gasLimitPerCallOverride: gasLimitOverride,
+                },
+            });
+            return {
+                blockNumber: mixedQuote.blockNumber,
+                approxGasUsedPerSuccessCall: mixedQuote.approxGasUsedPerSuccessCall,
+                results: mixedQuote.results.map((result) => {
+                    if (result.success) {
+                        switch (functionName) {
+                            case 'quoteExactInput':
+                            case 'quoteExactOutput':
+                                return {
+                                    success: true,
+                                    result: [
+                                        result.result[0],
+                                        Array(inputs.length),
+                                        Array(inputs.length),
+                                        result.result[1],
+                                    ],
+                                };
+                            default:
+                                throw new Error(`Unsupported function name: ${functionName}`);
+                        }
+                    }
+                    else {
+                        return result;
+                    }
+                }),
+            };
+        }
+        else {
+            return await this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+                address: this.getQuoterAddress(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol),
+                contractInterface: this.getContractInterface(useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol),
+                functionName,
+                functionParams: inputs,
+                providerConfig,
+                additionalConfig: {
+                    gasLimitPerCallOverride: gasLimitOverride,
+                },
+            });
+        }
+    }
+    async getQuotesManyData(amounts, routes, functionName, _providerConfig) {
+        var _a, _b;
+        const useMixedRouteQuoter = routes.some((route) => route.protocol === Protocol.V2) ||
+            routes.some((route) => route.protocol === Protocol.MIXED);
+        const useV4RouteQuoter = routes.some((route) => route.protocol === Protocol.V4) &&
+            !useMixedRouteQuoter;
+        const mixedRouteContainsV4Pool = useMixedRouteQuoter
+            ? routes.some((route) => route.protocol === Protocol.MIXED &&
+                route.pools.some((pool) => pool instanceof V4Pool))
+            : false;
+        const protocol = useMixedRouteQuoter
+            ? Protocol.MIXED
+            : useV4RouteQuoter
+                ? Protocol.V4
+                : Protocol.V3;
+        const optimisticCachedRoutes = (_a = _providerConfig === null || _providerConfig === void 0 ? void 0 : _providerConfig.optimisticCachedRoutes) !== null && _a !== void 0 ? _a : false;
+        /// Validate that there are no incorrect routes / function combinations
+        this.validateRoutes(routes, functionName, useMixedRouteQuoter);
+        let multicallChunk = this.batchParams(optimisticCachedRoutes, protocol).multicallChunk;
+        let gasLimitOverride = this.batchParams(optimisticCachedRoutes, protocol).gasLimitPerCall;
+        const { baseBlockOffset, rollback } = this.blockNumberConfig(protocol);
+        // Apply the base block offset if provided
+        const originalBlockNumber = await this.provider.getBlockNumber();
+        const providerConfig = {
+            ..._providerConfig,
+            blockNumber: (_b = _providerConfig === null || _providerConfig === void 0 ? void 0 : _providerConfig.blockNumber) !== null && _b !== void 0 ? _b : originalBlockNumber + baseBlockOffset,
+        };
+        const inputs = _(routes)
+            .flatMap((route) => {
+            const encodedRoute = this.encodeRouteToPath(route, functionName, mixedRouteContainsV4Pool);
+            const routeInputs = amounts.map((amount) => {
+                switch (route.protocol) {
+                    case Protocol.V4:
+                        return [
+                            {
+                                exactCurrency: getAddress(amount.currency),
+                                path: encodedRoute,
+                                exactAmount: amount.quotient.toString(),
+                            },
+                        ];
+                    case Protocol.MIXED:
+                        if (mixedRouteContainsV4Pool) {
+                            return [
+                                encodedRoute,
+                                {
+                                    nonEncodableData: route.pools.map((_) => {
+                                        return {
+                                            hookData: '0x',
+                                        };
+                                    }),
+                                },
+                                amount.quotient.toString(),
+                            ];
+                        }
+                        else {
+                            return [encodedRoute, amount.quotient.toString()];
+                        }
+                    default:
+                        return [
+                            encodedRoute,
+                            `0x${amount.quotient.toString(16)}`,
+                        ];
+                }
+            });
+            return routeInputs;
+        })
+            .value();
+        const normalizedChunk = Math.ceil(inputs.length / Math.ceil(inputs.length / multicallChunk));
+        const inputsChunked = _.chunk(inputs, normalizedChunk);
+        let quoteStates = _.map(inputsChunked, (inputChunk) => {
+            return {
+                status: 'pending',
+                inputs: inputChunk,
+            };
+        });
+        log.info(`About to get ${inputs.length} quotes in chunks of ${normalizedChunk} [${_.map(inputsChunked, (i) => i.length).join(',')}] ${gasLimitOverride
+            ? `with a gas limit override of ${gasLimitOverride}`
+            : ''} and block number: ${await providerConfig.blockNumber} [Original before offset: ${originalBlockNumber}].`);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteBatchSize`, inputs.length, MetricLoggerUnit.Count);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteBatchSize_${ID_TO_NETWORK_NAME(this.chainId)}`, inputs.length, MetricLoggerUnit.Count);
+        const startTime = Date.now();
+        let haveRetriedForSuccessRate = false;
+        let haveRetriedForBlockHeader = false;
+        let blockHeaderRetryAttemptNumber = 0;
+        let haveIncrementedBlockHeaderFailureCounter = false;
+        let blockHeaderRolledBack = false;
+        let haveRetriedForBlockConflictError = false;
+        let haveRetriedForOutOfGas = false;
+        let haveRetriedForTimeout = false;
+        let haveRetriedForUnknownReason = false;
+        let finalAttemptNumber = 1;
+        const expectedCallsMade = quoteStates.length;
+        let totalCallsMade = 0;
+        const { results: quoteResults, blockNumber, approxGasUsedPerSuccessCall, } = await retry(async (_bail, attemptNumber) => {
+            haveIncrementedBlockHeaderFailureCounter = false;
+            finalAttemptNumber = attemptNumber;
+            const [success, failed, pending] = this.partitionQuotes(quoteStates);
+            log.info(`Starting attempt: ${attemptNumber}.
+          Currently ${success.length} success, ${failed.length} failed, ${pending.length} pending.
+          Gas limit override: ${gasLimitOverride} Block number override: ${providerConfig.blockNumber}.`);
+            quoteStates = await Promise.all(_.map(quoteStates, async (quoteState, idx) => {
+                if (quoteState.status == 'success') {
+                    return quoteState;
+                }
+                // QuoteChunk is pending or failed, so we try again
+                const { inputs } = quoteState;
+                try {
+                    totalCallsMade = totalCallsMade + 1;
+                    const results = await this.consolidateResults(protocol, useMixedRouteQuoter, mixedRouteContainsV4Pool, functionName, inputs, providerConfig, gasLimitOverride);
+                    const successRateError = this.validateSuccessRate(results.results, haveRetriedForSuccessRate, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes);
+                    if (successRateError) {
+                        return {
+                            status: 'failed',
+                            inputs,
+                            reason: successRateError,
+                            results,
+                        };
+                    }
+                    return {
+                        status: 'success',
+                        inputs,
+                        results,
+                    };
+                }
+                catch (err) {
+                    // Error from providers have huge messages that include all the calldata and fill the logs.
+                    // Catch them and rethrow with shorter message.
+                    if (err.message.includes('header not found')) {
+                        return {
+                            status: 'failed',
+                            inputs,
+                            reason: new ProviderBlockHeaderError(err.message.slice(0, 500)),
+                        };
+                    }
+                    if (err.message.includes('timeout')) {
+                        return {
+                            status: 'failed',
+                            inputs,
+                            reason: new ProviderTimeoutError(`Req ${idx}/${quoteStates.length}. Request had ${inputs.length} inputs. ${err.message.slice(0, 500)}`),
+                        };
+                    }
+                    if (err.message.includes('out of gas')) {
+                        return {
+                            status: 'failed',
+                            inputs,
+                            reason: new ProviderGasError(err.message.slice(0, 500)),
+                        };
+                    }
+                    return {
+                        status: 'failed',
+                        inputs,
+                        reason: new Error(`Unknown error from provider: ${err.message.slice(0, 500)}`),
+                    };
+                }
+            }));
+            const [successfulQuoteStates, failedQuoteStates, pendingQuoteStates] = this.partitionQuotes(quoteStates);
+            if (pendingQuoteStates.length > 0) {
+                throw new Error('Pending quote after waiting for all promises.');
+            }
+            let retryAll = false;
+            const blockNumberError = this.validateBlockNumbers(successfulQuoteStates, inputsChunked.length, gasLimitOverride);
+            // If there is a block number conflict we retry all the quotes.
+            if (blockNumberError) {
+                retryAll = true;
+            }
+            const reasonForFailureStr = _.map(failedQuoteStates, (failedQuoteState) => failedQuoteState.reason.name).join(', ');
+            if (failedQuoteStates.length > 0) {
+                log.info(`On attempt ${attemptNumber}: ${failedQuoteStates.length}/${quoteStates.length} quotes failed. Reasons: ${reasonForFailureStr}`);
+                for (const failedQuoteState of failedQuoteStates) {
+                    const { reason: error } = failedQuoteState;
+                    log.info({ error }, `[QuoteFetchError] Attempt ${attemptNumber}. ${error.message}`);
+                    if (error instanceof BlockConflictError) {
+                        if (!haveRetriedForBlockConflictError) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteBlockConflictErrorRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForBlockConflictError = true;
+                        }
+                        retryAll = true;
+                    }
+                    else if (error instanceof ProviderBlockHeaderError) {
+                        if (!haveRetriedForBlockHeader) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteBlockHeaderNotFoundRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForBlockHeader = true;
+                        }
+                        // Ensure that if multiple calls fail due to block header in the current pending batch,
+                        // we only count once.
+                        if (!haveIncrementedBlockHeaderFailureCounter) {
+                            blockHeaderRetryAttemptNumber =
+                                blockHeaderRetryAttemptNumber + 1;
+                            haveIncrementedBlockHeaderFailureCounter = true;
+                        }
+                        if (rollback.enabled) {
+                            const { rollbackBlockOffset, attemptsBeforeRollback } = rollback;
+                            if (blockHeaderRetryAttemptNumber >= attemptsBeforeRollback &&
+                                !blockHeaderRolledBack) {
+                                log.info(`Attempt ${attemptNumber}. Have failed due to block header ${blockHeaderRetryAttemptNumber - 1} times. Rolling back block number by ${rollbackBlockOffset} for next retry`);
+                                providerConfig.blockNumber = providerConfig.blockNumber
+                                    ? (await providerConfig.blockNumber) + rollbackBlockOffset
+                                    : (await this.provider.getBlockNumber()) +
+                                        rollbackBlockOffset;
+                                retryAll = true;
+                                blockHeaderRolledBack = true;
+                            }
+                        }
+                    }
+                    else if (error instanceof ProviderTimeoutError) {
+                        if (!haveRetriedForTimeout) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteTimeoutRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForTimeout = true;
+                        }
+                    }
+                    else if (error instanceof ProviderGasError) {
+                        if (!haveRetriedForOutOfGas) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteOutOfGasExceptionRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForOutOfGas = true;
+                        }
+                        gasLimitOverride =
+                            this.gasErrorFailureOverride(protocol).gasLimitOverride;
+                        multicallChunk =
+                            this.gasErrorFailureOverride(protocol).multicallChunk;
+                        retryAll = true;
+                    }
+                    else if (error instanceof SuccessRateError) {
+                        if (!haveRetriedForSuccessRate) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteSuccessRateRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForSuccessRate = true;
+                            // Low success rate can indicate too little gas given to each call.
+                            gasLimitOverride =
+                                this.successRateFailureOverrides(protocol).gasLimitOverride;
+                            multicallChunk =
+                                this.successRateFailureOverrides(protocol).multicallChunk;
+                            retryAll = true;
+                        }
+                    }
+                    else {
+                        if (!haveRetriedForUnknownReason) {
+                            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteUnknownReasonRetry`, 1, MetricLoggerUnit.Count);
+                            haveRetriedForUnknownReason = true;
+                        }
+                    }
+                }
+            }
+            if (retryAll) {
+                log.info(`Attempt ${attemptNumber}. Resetting all requests to pending for next attempt.`);
+                const normalizedChunk = Math.ceil(inputs.length / Math.ceil(inputs.length / multicallChunk));
+                const inputsChunked = _.chunk(inputs, normalizedChunk);
+                quoteStates = _.map(inputsChunked, (inputChunk) => {
+                    return {
+                        status: 'pending',
+                        inputs: inputChunk,
+                    };
+                });
+            }
+            if (failedQuoteStates.length > 0) {
+                // TODO: Work with Arbitrum to find a solution for making large multicalls with gas limits that always
+                // successfully.
+                //
+                // On Arbitrum we can not set a gas limit for every call in the multicall and guarantee that
+                // we will not run out of gas on the node. This is because they have a different way of accounting
+                // for gas, that seperates storage and compute gas costs, and we can not cover both in a single limit.
+                //
+                // To work around this and avoid throwing errors when really we just couldn't get a quote, we catch this
+                // case and return 0 quotes found.
+                if ((this.chainId == ChainId.ARBITRUM_ONE ||
+                    this.chainId == ChainId.ARBITRUM_GOERLI) &&
+                    _.every(failedQuoteStates, (failedQuoteState) => failedQuoteState.reason instanceof ProviderGasError) &&
+                    attemptNumber == this.retryOptions.retries) {
+                    log.error(`Failed to get quotes on Arbitrum due to provider gas error issue. Overriding error to return 0 quotes.`);
+                    return {
+                        results: [],
+                        blockNumber: BigNumber.from(0),
+                        approxGasUsedPerSuccessCall: 0,
+                    };
+                }
+                throw new Error(`Failed to get ${failedQuoteStates.length} quotes. Reasons: ${reasonForFailureStr}`);
+            }
+            const callResults = _.map(successfulQuoteStates, (quoteState) => quoteState.results);
+            return {
+                results: _.flatMap(callResults, (result) => result.results),
+                blockNumber: BigNumber.from(callResults[0].blockNumber),
+                approxGasUsedPerSuccessCall: stats.percentile(_.map(callResults, (result) => result.approxGasUsedPerSuccessCall), 100),
+            };
+        }, {
+            retries: DEFAULT_BATCH_RETRIES,
+            ...this.retryOptions,
+        });
+        const routesQuotes = this.processQuoteResults(quoteResults, routes, amounts, BigNumber.from(gasLimitOverride), useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes);
+        const endTime = Date.now();
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteLatency`, endTime - startTime, MetricLoggerUnit.Milliseconds);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteApproxGasUsedPerSuccessfulCall`, approxGasUsedPerSuccessCall, MetricLoggerUnit.Count);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteNumRetryLoops`, finalAttemptNumber - 1, MetricLoggerUnit.Count);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteTotalCallsToProvider`, totalCallsMade, MetricLoggerUnit.Count);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteExpectedCallsToProvider`, expectedCallsMade, MetricLoggerUnit.Count);
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteNumRetriedCalls`, totalCallsMade - expectedCallsMade, MetricLoggerUnit.Count);
+        const [successfulQuotes, failedQuotes] = _(routesQuotes)
+            .flatMap((routeWithQuotes) => routeWithQuotes[1])
+            .partition((quote) => quote.quote != null)
+            .value();
+        log.info(`Got ${successfulQuotes.length} successful quotes, ${failedQuotes.length} failed quotes. Took ${finalAttemptNumber - 1} attempt loops. Total calls made to provider: ${totalCallsMade}. Have retried for timeout: ${haveRetriedForTimeout}`);
+        // Log total routes
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}RoutesLength`, routesQuotes.length, MetricLoggerUnit.Count);
+        // Log total quotes
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}RoutesQuotesLength`, successfulQuotes.length + failedQuotes.length, MetricLoggerUnit.Count);
+        // log successful quotes
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}RoutesSuccessfulQuotesLength`, successfulQuotes.length, MetricLoggerUnit.Count);
+        // log failed quotes
+        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}RoutesFailedQuotesLength`, failedQuotes.length, MetricLoggerUnit.Count);
+        return {
+            routesWithQuotes: routesQuotes,
+            blockNumber,
+        };
+    }
+    partitionQuotes(quoteStates) {
+        const successfulQuoteStates = _.filter(quoteStates, (quoteState) => quoteState.status == 'success');
+        const failedQuoteStates = _.filter(quoteStates, (quoteState) => quoteState.status == 'failed');
+        const pendingQuoteStates = _.filter(quoteStates, (quoteState) => quoteState.status == 'pending');
+        return [successfulQuoteStates, failedQuoteStates, pendingQuoteStates];
+    }
+    processQuoteResults(quoteResults, routes, amounts, gasLimit, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes) {
+        const routesQuotes = [];
+        const quotesResultsByRoute = _.chunk(quoteResults, amounts.length);
+        const debugFailedQuotes = [];
+        for (let i = 0; i < quotesResultsByRoute.length; i++) {
+            const route = routes[i];
+            const quoteResults = quotesResultsByRoute[i];
+            const quotes = _.map(quoteResults, (quoteResult, index) => {
+                var _a, _b, _c;
+                const amount = amounts[index];
+                if (!quoteResult.success) {
+                    const percent = (100 / amounts.length) * (index + 1);
+                    const amountStr = amount.toFixed(Math.min(amount.currency.decimals, 2));
+                    const routeStr = routeToString(route);
+                    debugFailedQuotes.push({
+                        route: routeStr,
+                        percent,
+                        amount: amountStr,
+                    });
+                    if (route.protocol === Protocol.V4 &&
+                        route.pools.some(pool => pool.hooks !== ADDRESS_ZERO)) {
+                        log.debug({
+                            route: routeStr,
+                            quoteResult,
+                        }, 'Failed to get quote for V4 route with hooks');
+                        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteFailedWithHooks`, 1, MetricLoggerUnit.Count);
+                        route.pools.forEach((pool) => {
+                            if (pool.hooks !== ADDRESS_ZERO) {
+                                metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteFailedWithHooks${pool.hooks}`, 1, MetricLoggerUnit.Count);
+                            }
+                        });
+                    }
+                    if (route.protocol === Protocol.MIXED &&
+                        ((_b = (_a = route.pools) === null || _a === void 0 ? void 0 : _a.some) === null || _b === void 0 ? void 0 : _b.call(_a, pool => pool instanceof V4Pool && pool.hooks !== ADDRESS_ZERO))) {
+                        log.debug({
+                            route: routeStr,
+                            quoteResult,
+                        }, 'Failed to get quote for Mixed protocol route with hooks');
+                        route.pools.forEach((pool) => {
+                            if (pool instanceof V4Pool && pool.hooks !== ADDRESS_ZERO) {
+                                metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteFailedWithHooks${pool.hooks}`, 1, MetricLoggerUnit.Count);
+                            }
+                        });
+                        metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteFailedWithHooks`, 1, MetricLoggerUnit.Count);
+                    }
+                    return {
+                        amount,
+                        quote: null,
+                        sqrtPriceX96AfterList: null,
+                        gasEstimate: (_c = quoteResult.gasUsed) !== null && _c !== void 0 ? _c : null,
+                        gasLimit: gasLimit,
+                        initializedTicksCrossedList: null,
+                    };
+                }
+                return {
+                    amount,
+                    quote: quoteResult.result[0],
+                    sqrtPriceX96AfterList: quoteResult.result[1],
+                    initializedTicksCrossedList: quoteResult.result[2],
+                    gasEstimate: quoteResult.result[3],
+                    gasLimit: gasLimit,
+                };
+            });
+            routesQuotes.push([route, quotes]);
+        }
+        // For routes and amounts that we failed to get a quote for, group them by route
+        // and batch them together before logging to minimize number of logs.
+        const debugChunk = 80;
+        _.forEach(_.chunk(debugFailedQuotes, debugChunk), (quotes, idx) => {
+            const failedQuotesByRoute = _.groupBy(quotes, (q) => q.route);
+            const failedFlat = _.mapValues(failedQuotesByRoute, (f) => _(f)
+                .map((f) => `${f.percent}%[${f.amount}]`)
+                .join(','));
+            log.info({
+                failedQuotes: _.map(failedFlat, (amounts, routeStr) => `${routeStr} : ${amounts}`),
+            }, `Failed on chain quotes for routes Part ${idx}/${Math.ceil(debugFailedQuotes.length / debugChunk)}`);
+        });
+        return routesQuotes;
+    }
+    validateBlockNumbers(successfulQuoteStates, totalCalls, gasLimitOverride) {
+        if (successfulQuoteStates.length <= 1) {
+            return null;
+        }
+        const results = _.map(successfulQuoteStates, (quoteState) => quoteState.results);
+        const blockNumbers = _.map(results, (result) => result.blockNumber);
+        const uniqBlocks = _(blockNumbers)
+            .map((blockNumber) => blockNumber.toNumber())
+            .uniq()
+            .value();
+        if (uniqBlocks.length == 1) {
+            return null;
+        }
+        /* if (
+          uniqBlocks.length == 2 &&
+          Math.abs(uniqBlocks[0]! - uniqBlocks[1]!) <= 1
+        ) {
+          return null;
+        } */
+        return new BlockConflictError(`Quotes returned from different blocks. ${uniqBlocks}. ${totalCalls} calls were made with gas limit ${gasLimitOverride}`);
+    }
+    validateSuccessRate(allResults, haveRetriedForSuccessRate, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes) {
+        const numResults = allResults.length;
+        const numSuccessResults = allResults.filter((result) => result.success).length;
+        const successRate = (1.0 * numSuccessResults) / numResults;
+        const { quoteMinSuccessRate } = this.batchParams(optimisticCachedRoutes, protocol);
+        if (successRate < quoteMinSuccessRate) {
+            if (haveRetriedForSuccessRate) {
+                log.info(`Quote success rate still below threshold despite retry. Continuing. ${quoteMinSuccessRate}: ${successRate}`);
+                metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteRetriedSuccessRateLow`, successRate, MetricLoggerUnit.Percent);
+                return;
+            }
+            metric.putMetric(`${this.metricsPrefix(this.chainId, useMixedRouteQuoter, mixedRouteContainsV4Pool, protocol, optimisticCachedRoutes)}QuoteSuccessRateLow`, successRate, MetricLoggerUnit.Percent);
+            return new SuccessRateError(`Quote success rate below threshold of ${quoteMinSuccessRate}: ${successRate}`);
+        }
+    }
+    /**
+     * Throw an error for incorrect routes / function combinations
+     * @param routes Any combination of V3, V2, and Mixed routes.
+     * @param functionName
+     * @param useMixedRouteQuoter true if there are ANY V2Routes or MixedRoutes in the routes parameter
+     */
+    validateRoutes(routes, functionName, useMixedRouteQuoter) {
+        /// We do not send any V3Routes to new qutoer becuase it is not deployed on chains besides mainnet
+        if (routes.some((route) => route.protocol === Protocol.V3) &&
+            useMixedRouteQuoter) {
+            throw new Error(`Cannot use mixed route quoter with V3 routes`);
+        }
+        /// We cannot call quoteExactOutput with V2 or Mixed routes
+        if (functionName === 'quoteExactOutput' && useMixedRouteQuoter) {
+            throw new Error('Cannot call quoteExactOutput with V2 or Mixed routes');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"on-chain-quote-provider.js","sourceRoot":"","sources":["../../../src/providers/on-chain-quote-provider.ts"],"names":[],"mappings":"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"}