@fanx-protocol/smart-order-router 0.0.1

package/build/main/providers/multicall-provider.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMulticallProvider = void 0;
+/**
+ * Provider for fetching data on chain using multicall contracts.
+ *
+ * @export
+ * @abstract
+ * @class IMulticallProvider
+ * @template TMulticallConfig
+ */
+class IMulticallProvider {
+}
+exports.IMulticallProvider = IMulticallProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGljYWxsLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9tdWx0aWNhbGwtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBc0RBOzs7Ozs7O0dBT0c7QUFDSCxNQUFzQixrQkFBa0I7Q0ErRHZDO0FBL0RELGdEQStEQyJ9

package/build/main/providers/multicall-uniswap-provider.d.ts

@@ -0,0 +1,37 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { BaseProvider } from '@ethersproject/providers';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { CallMultipleFunctionsOnSameContractParams, CallSameFunctionOnContractWithMultipleParams, CallSameFunctionOnMultipleContractsParams, IMulticallProvider, Result } from './multicall-provider';
+export declare type UniswapMulticallConfig = {
+    gasLimitPerCallOverride?: number;
+};
+/**
+ * The UniswapMulticall contract has added functionality for limiting the amount of gas
+ * that each call within the multicall can consume. This is useful for operations where
+ * a call could consume such a large amount of gas that it causes the node to error out
+ * with an out of gas error.
+ *
+ * @export
+ * @class UniswapMulticallProvider
+ */
+export declare class UniswapMulticallProvider extends IMulticallProvider<UniswapMulticallConfig> {
+    protected chainId: ChainId;
+    protected provider: BaseProvider;
+    protected gasLimitPerCall: number;
+    private multicallContract;
+    constructor(chainId: ChainId, provider: BaseProvider, gasLimitPerCall?: number);
+    callSameFunctionOnMultipleContracts<TFunctionParams extends any[] | undefined, TReturn = any>(params: CallSameFunctionOnMultipleContractsParams<TFunctionParams>): Promise<{
+        blockNumber: BigNumber;
+        results: Result<TReturn>[];
+    }>;
+    callSameFunctionOnContractWithMultipleParams<TFunctionParams extends any[] | undefined, TReturn>(params: CallSameFunctionOnContractWithMultipleParams<TFunctionParams, UniswapMulticallConfig>): Promise<{
+        blockNumber: BigNumber;
+        results: Result<TReturn>[];
+        approxGasUsedPerSuccessCall: number;
+    }>;
+    callMultipleFunctionsOnSameContract<TFunctionParams extends any[] | undefined, TReturn>(params: CallMultipleFunctionsOnSameContractParams<TFunctionParams, UniswapMulticallConfig>): Promise<{
+        blockNumber: BigNumber;
+        results: Result<TReturn>[];
+        approxGasUsedPerSuccessCall: number;
+    }>;
+}

package/build/main/providers/multicall-uniswap-provider.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapMulticallProvider = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const stats_lite_1 = __importDefault(require("stats-lite"));
+const UniswapInterfaceMulticall__factory_1 = require("../types/v3/factories/UniswapInterfaceMulticall__factory");
+const addresses_1 = require("../util/addresses");
+const log_1 = require("../util/log");
+const multicall_provider_1 = require("./multicall-provider");
+/**
+ * The UniswapMulticall contract has added functionality for limiting the amount of gas
+ * that each call within the multicall can consume. This is useful for operations where
+ * a call could consume such a large amount of gas that it causes the node to error out
+ * with an out of gas error.
+ *
+ * @export
+ * @class UniswapMulticallProvider
+ */
+class UniswapMulticallProvider extends multicall_provider_1.IMulticallProvider {
+    constructor(chainId, provider, gasLimitPerCall = 1000000) {
+        super();
+        this.chainId = chainId;
+        this.provider = provider;
+        this.gasLimitPerCall = gasLimitPerCall;
+        const multicallAddress = addresses_1.UNISWAP_MULTICALL_ADDRESSES[this.chainId];
+        if (!multicallAddress) {
+            throw new Error(`No address for Uniswap Multicall Contract on chain id: ${chainId}`);
+        }
+        this.multicallContract = UniswapInterfaceMulticall__factory_1.UniswapInterfaceMulticall__factory.connect(multicallAddress, this.provider);
+    }
+    async callSameFunctionOnMultipleContracts(params) {
+        var _a;
+        const { addresses, contractInterface, functionName, functionParams, providerConfig, } = params;
+        const blockNumberOverride = (_a = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber) !== null && _a !== void 0 ? _a : undefined;
+        const fragment = contractInterface.getFunction(functionName);
+        const callData = contractInterface.encodeFunctionData(fragment, functionParams);
+        const calls = lodash_1.default.map(addresses, (address) => {
+            return {
+                target: address,
+                callData,
+                gasLimit: this.gasLimitPerCall,
+            };
+        });
+        log_1.log.debug({ calls }, `About to multicall for ${functionName} across ${addresses.length} addresses`);
+        const { blockNumber, returnData: aggregateResults } = await this.multicallContract.callStatic.multicall(calls, {
+            blockTag: blockNumberOverride,
+        });
+        const results = [];
+        for (let i = 0; i < aggregateResults.length; i++) {
+            const { success, returnData } = aggregateResults[i];
+            // Return data "0x" is sometimes returned for invalid calls.
+            if (!success || returnData.length <= 2) {
+                log_1.log.debug({ result: aggregateResults[i] }, `Invalid result calling ${functionName} on address ${addresses[i]}`);
+                results.push({
+                    success: false,
+                    returnData,
+                });
+                continue;
+            }
+            results.push({
+                success: true,
+                result: contractInterface.decodeFunctionResult(fragment, returnData),
+            });
+        }
+        log_1.log.debug({ results }, `Results for multicall on ${functionName} across ${addresses.length} addresses as of block ${blockNumber}`);
+        return { blockNumber, results };
+    }
+    async callSameFunctionOnContractWithMultipleParams(params) {
+        var _a, _b;
+        const { address, contractInterface, functionName, functionParams, additionalConfig, providerConfig, } = params;
+        const fragment = contractInterface.getFunction(functionName);
+        const gasLimitPerCall = (_a = additionalConfig === null || additionalConfig === void 0 ? void 0 : additionalConfig.gasLimitPerCallOverride) !== null && _a !== void 0 ? _a : this.gasLimitPerCall;
+        const blockNumberOverride = (_b = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber) !== null && _b !== void 0 ? _b : undefined;
+        const calls = lodash_1.default.map(functionParams, (functionParam) => {
+            const callData = contractInterface.encodeFunctionData(fragment, functionParam);
+            return {
+                target: address,
+                callData,
+                gasLimit: gasLimitPerCall,
+            };
+        });
+        log_1.log.debug({ calls }, `About to multicall for ${functionName} at address ${address} with ${functionParams.length} different sets of params`);
+        const { blockNumber, returnData: aggregateResults } = await this.multicallContract.callStatic.multicall(calls, {
+            blockTag: blockNumberOverride,
+        });
+        const results = [];
+        const gasUsedForSuccess = [];
+        for (let i = 0; i < aggregateResults.length; i++) {
+            const { success, returnData, gasUsed } = aggregateResults[i];
+            // Return data "0x" is sometimes returned for invalid pools.
+            if (!success || returnData.length <= 2) {
+                log_1.log.debug({ result: aggregateResults[i] }, `Invalid result calling ${functionName} address ${address} with params ${functionParams[i]}`);
+                results.push({
+                    success: false,
+                    returnData,
+                    gasUsed,
+                });
+                continue;
+            }
+            gasUsedForSuccess.push(gasUsed.toNumber());
+            results.push({
+                success: true,
+                result: contractInterface.decodeFunctionResult(fragment, returnData),
+            });
+        }
+        log_1.log.debug({ results, functionName, address }, `Results for multicall for ${functionName} at address ${address} with ${functionParams.length} different sets of params. Results as of block ${blockNumber}`);
+        return {
+            blockNumber,
+            results,
+            approxGasUsedPerSuccessCall: stats_lite_1.default.percentile(gasUsedForSuccess, 99),
+        };
+    }
+    async callMultipleFunctionsOnSameContract(params) {
+        var _a, _b;
+        const { address, contractInterface, functionNames, functionParams, additionalConfig, providerConfig, } = params;
+        const gasLimitPerCall = (_a = additionalConfig === null || additionalConfig === void 0 ? void 0 : additionalConfig.gasLimitPerCallOverride) !== null && _a !== void 0 ? _a : this.gasLimitPerCall;
+        const blockNumberOverride = (_b = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber) !== null && _b !== void 0 ? _b : undefined;
+        const calls = lodash_1.default.map(functionNames, (functionName, i) => {
+            const fragment = contractInterface.getFunction(functionName);
+            const param = functionParams ? functionParams[i] : [];
+            const callData = contractInterface.encodeFunctionData(fragment, param);
+            return {
+                target: address,
+                callData,
+                gasLimit: gasLimitPerCall,
+            };
+        });
+        log_1.log.debug({ calls }, `About to multicall for ${functionNames.length} functions at address ${address} with ${functionParams === null || functionParams === void 0 ? void 0 : functionParams.length} different sets of params`);
+        const { blockNumber, returnData: aggregateResults } = await this.multicallContract.callStatic.multicall(calls, {
+            blockTag: blockNumberOverride,
+        });
+        const results = [];
+        const gasUsedForSuccess = [];
+        for (let i = 0; i < aggregateResults.length; i++) {
+            const fragment = contractInterface.getFunction(functionNames[i]);
+            const { success, returnData, gasUsed } = aggregateResults[i];
+            // Return data "0x" is sometimes returned for invalid pools.
+            if (!success || returnData.length <= 2) {
+                log_1.log.debug({ result: aggregateResults[i] }, `Invalid result calling ${functionNames[i]} with ${functionParams ? functionParams[i] : '0'} params`);
+                results.push({
+                    success: false,
+                    returnData,
+                });
+                continue;
+            }
+            gasUsedForSuccess.push(gasUsed.toNumber());
+            results.push({
+                success: true,
+                result: contractInterface.decodeFunctionResult(fragment, returnData),
+            });
+        }
+        log_1.log.debug({ results, functionNames, address }, `Results for multicall for ${functionNames.length} functions at address ${address} with ${functionParams ? functionParams.length : ' 0'} different sets of params. Results as of block ${blockNumber}`);
+        return {
+            blockNumber,
+            results,
+            approxGasUsedPerSuccessCall: stats_lite_1.default.percentile(gasUsedForSuccess, 99),
+        };
+    }
+}
+exports.UniswapMulticallProvider = UniswapMulticallProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multicall-uniswap-provider.js","sourceRoot":"","sources":["../../../src/providers/multicall-uniswap-provider.ts"],"names":[],"mappings":"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"}

package/build/main/providers/on-chain-gas-price-provider.d.ts

@@ -0,0 +1,19 @@
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { EIP1559GasPriceProvider } from './eip-1559-gas-price-provider';
+import { GasPrice, IGasPriceProvider } from './gas-price-provider';
+import { LegacyGasPriceProvider } from './legacy-gas-price-provider';
+/**
+ * Gets gas prices on chain. If the chain supports EIP-1559 and has the feeHistory API,
+ * uses the EIP1559 provider. Otherwise it will use a legacy provider that uses eth_gasPrice
+ *
+ * @export
+ * @class OnChainGasPriceProvider
+ */
+export declare class OnChainGasPriceProvider extends IGasPriceProvider {
+    protected chainId: ChainId;
+    protected eip1559GasPriceProvider: EIP1559GasPriceProvider;
+    protected legacyGasPriceProvider: LegacyGasPriceProvider;
+    protected eipChains: ChainId[];
+    constructor(chainId: ChainId, eip1559GasPriceProvider: EIP1559GasPriceProvider, legacyGasPriceProvider: LegacyGasPriceProvider, eipChains?: ChainId[]);
+    getGasPrice(latestBlockNumber: number, requestBlockNumber?: number): Promise<GasPrice>;
+}

package/build/main/providers/on-chain-gas-price-provider.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainGasPriceProvider = void 0;
+const l2FeeChains_1 = require("../util/l2FeeChains");
+const gas_price_provider_1 = require("./gas-price-provider");
+const DEFAULT_EIP_1559_SUPPORTED_CHAINS = [
+    // ChainId.MAINNET,
+    // ChainId.GOERLI,
+    // ChainId.POLYGON_MUMBAI,
+    // ChainId.ARBITRUM_ONE,
+    ...l2FeeChains_1.opStackChains,
+];
+/**
+ * Gets gas prices on chain. If the chain supports EIP-1559 and has the feeHistory API,
+ * uses the EIP1559 provider. Otherwise it will use a legacy provider that uses eth_gasPrice
+ *
+ * @export
+ * @class OnChainGasPriceProvider
+ */
+class OnChainGasPriceProvider extends gas_price_provider_1.IGasPriceProvider {
+    constructor(chainId, eip1559GasPriceProvider, legacyGasPriceProvider, eipChains = DEFAULT_EIP_1559_SUPPORTED_CHAINS) {
+        super();
+        this.chainId = chainId;
+        this.eip1559GasPriceProvider = eip1559GasPriceProvider;
+        this.legacyGasPriceProvider = legacyGasPriceProvider;
+        this.eipChains = eipChains;
+    }
+    async getGasPrice(latestBlockNumber, requestBlockNumber) {
+        if (this.eipChains.includes(this.chainId)) {
+            return this.eip1559GasPriceProvider.getGasPrice(latestBlockNumber, requestBlockNumber);
+        }
+        return this.legacyGasPriceProvider.getGasPrice(latestBlockNumber, requestBlockNumber);
+    }
+}
+exports.OnChainGasPriceProvider = OnChainGasPriceProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib24tY2hhaW4tZ2FzLXByaWNlLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9vbi1jaGFpbi1nYXMtcHJpY2UtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEscURBQW9EO0FBRXBELDZEQUFtRTtBQUduRSxNQUFNLGlDQUFpQyxHQUFHO0lBQ3hDLG1CQUFtQjtJQUNuQixrQkFBa0I7SUFDbEIsMEJBQTBCO0lBQzFCLHdCQUF3QjtJQUN4QixHQUFHLDJCQUFhO0NBQ2pCLENBQUM7QUFFRjs7Ozs7O0dBTUc7QUFDSCxNQUFhLHVCQUF3QixTQUFRLHNDQUFpQjtJQUM1RCxZQUNZLE9BQWdCLEVBQ2hCLHVCQUFnRCxFQUNoRCxzQkFBOEMsRUFDOUMsWUFBdUIsaUNBQWlDO1FBRWxFLEtBQUssRUFBRSxDQUFDO1FBTEUsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNoQiw0QkFBdUIsR0FBdkIsdUJBQXVCLENBQXlCO1FBQ2hELDJCQUFzQixHQUF0QixzQkFBc0IsQ0FBd0I7UUFDOUMsY0FBUyxHQUFULFNBQVMsQ0FBK0M7SUFHcEUsQ0FBQztJQUVlLEtBQUssQ0FBQyxXQUFXLENBQy9CLGlCQUF5QixFQUN6QixrQkFBMkI7UUFFM0IsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDekMsT0FBTyxJQUFJLENBQUMsdUJBQXVCLENBQUMsV0FBVyxDQUM3QyxpQkFBaUIsRUFDakIsa0JBQWtCLENBQ25CLENBQUM7U0FDSDtRQUVELE9BQU8sSUFBSSxDQUFDLHNCQUFzQixDQUFDLFdBQVcsQ0FDNUMsaUJBQWlCLEVBQ2pCLGtCQUFrQixDQUNuQixDQUFDO0lBQ0osQ0FBQztDQUNGO0FBMUJELDBEQTBCQyJ9

package/build/main/providers/on-chain-quote-provider.d.ts

@@ -0,0 +1,258 @@
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { BytesLike } from '@ethersproject/bytes';
+import { BaseProvider } from '@ethersproject/providers';
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { Options as RetryOptions } from 'async-retry';
+import { SupportedRoutes, V3Route } from '../routers/router';
+import { CurrencyAmount } from '../util/amounts';
+import { Result } from './multicall-provider';
+import { UniswapMulticallProvider } from './multicall-uniswap-provider';
+import { ProviderConfig } from './provider';
+/**
+ * Emulate on-chain [PathKey](https://github.com/Uniswap/v4-periphery/blob/main/src/libraries/PathKey.sol#L8) struct
+ */
+export declare type PathKey = {
+    intermediateCurrency: string;
+    fee: BigNumberish;
+    tickSpacing: BigNumberish;
+    hooks: string;
+    hookData: BytesLike;
+};
+export declare type SupportedPath = string | PathKey[];
+/**
+ * Emulate on-chain [QuoteExactParams](https://github.com/Uniswap/v4-periphery/blob/main/src/interfaces/IQuoter.sol#L34) struct
+ */
+export declare type QuoteExactParams = {
+    exactCurrency: string;
+    path: PathKey[];
+    exactAmount: BigNumberish;
+};
+/**
+ * Emulate on-chain [ExtraQuoteExactInputParams](https://github.com/Uniswap/mixed-quoter/blob/main/src/interfaces/IMixedRouteQuoterV2.sol#L44C12-L44C38) struct
+ */
+declare type NonEncodableData = {
+    hookData: BytesLike;
+};
+export declare type ExtraQuoteExactInputParams = {
+    nonEncodableData: NonEncodableData[];
+};
+export declare type QuoteInputType = QuoteExactParams[] | [string, string] | [string, ExtraQuoteExactInputParams, string];
+/**
+ * An on chain quote for a swap.
+ */
+export declare type AmountQuote = {
+    amount: CurrencyAmount;
+    /**
+     * Quotes can be null (e.g. pool did not have enough liquidity).
+     */
+    quote: BigNumber | null;
+    /**
+     * For each pool in the route, the sqrtPriceX96 after the swap.
+     */
+    sqrtPriceX96AfterList: BigNumber[] | null;
+    /**
+     * For each pool in the route, the number of ticks crossed.
+     */
+    initializedTicksCrossedList: number[] | null;
+    /**
+     * An estimate of the gas used by the swap. This is returned by the multicall
+     * and is not necessarily accurate due to EIP-2929 causing gas costs to vary
+     * depending on if the slot has already been loaded in the call.
+     */
+    gasEstimate: BigNumber | null;
+    /**
+     * Final attempted gas limit set by the on-chain quote provider
+     */
+    gasLimit: BigNumber | null;
+};
+export declare class BlockConflictError extends Error {
+    name: string;
+}
+export declare class SuccessRateError extends Error {
+    name: string;
+}
+export declare class ProviderBlockHeaderError extends Error {
+    name: string;
+}
+export declare class ProviderTimeoutError extends Error {
+    name: string;
+}
+/**
+ * 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 declare class ProviderGasError extends Error {
+    name: string;
+}
+export declare type QuoteRetryOptions = RetryOptions;
+/**
+ * The V3 route and a list of quotes for that route.
+ */
+export declare type RouteWithQuotes<TRoute extends SupportedRoutes> = [
+    TRoute,
+    AmountQuote[]
+];
+/**
+ * Final consolidated return type of all on-chain quotes.
+ */
+export declare type OnChainQuotes<TRoute extends SupportedRoutes> = {
+    routesWithQuotes: RouteWithQuotes<TRoute>[];
+    blockNumber: BigNumber;
+};
+export declare type SupportedExactOutRoutes = V3Route;
+/**
+ * Provider for getting on chain quotes using routes containing V3 pools or V2 pools.
+ *
+ * @export
+ * @interface IOnChainQuoteProvider
+ */
+export interface IOnChainQuoteProvider {
+    /**
+     * For every route, gets an exactIn quotes for every amount provided.
+     * @notice While passing in exactIn V2Routes is supported, we recommend using the V2QuoteProvider to compute off chain quotes for V2 whenever possible
+     *
+     * @param amountIns The amounts to get quotes for.
+     * @param routes The routes to get quotes for.
+     * @param [providerConfig] The provider config.
+     * @returns For each route returns a RouteWithQuotes object that contains all the quotes.
+     * @returns The blockNumber used when generating the quotes.
+     */
+    getQuotesManyExactIn<TRoute extends SupportedRoutes>(amountIns: CurrencyAmount[], routes: TRoute[], providerConfig?: ProviderConfig): Promise<OnChainQuotes<TRoute>>;
+    /**
+     * For every route, gets ane exactOut quote for every amount provided.
+     * @notice This does not support quotes for MixedRoutes (routes with both V3 and V2 pools/pairs) or pure V2 routes
+     *
+     * @param amountOuts The amounts to get quotes for.
+     * @param routes The routes to get quotes for.
+     * @param [providerConfig] The provider config.
+     * @returns For each route returns a RouteWithQuotes object that contains all the quotes.
+     * @returns The blockNumber used when generating the quotes.
+     */
+    getQuotesManyExactOut<TRoute extends SupportedExactOutRoutes>(amountOuts: CurrencyAmount[], routes: TRoute[], providerConfig?: ProviderConfig): Promise<OnChainQuotes<TRoute>>;
+}
+/**
+ * The parameters for the multicalls we make.
+ *
+ * It is important to ensure that (gasLimitPerCall * multicallChunk) < providers gas limit per call.
+ *
+ * On chain quotes can consume a lot of gas (if the swap is so large that it swaps through a large
+ * number of ticks), so there is a risk of exceeded gas limits in these multicalls.
+ */
+export declare type BatchParams = {
+    /**
+     * The number of quotes to fetch in each multicall.
+     */
+    multicallChunk: number;
+    /**
+     * The maximum call to consume for each quote in the multicall.
+     */
+    gasLimitPerCall: number;
+    /**
+     * The minimum success rate for all quotes across all multicalls.
+     * If we set our gasLimitPerCall too low it could result in a large number of
+     * quotes failing due to out of gas. This parameters will fail the overall request
+     * in this case.
+     */
+    quoteMinSuccessRate: number;
+};
+/**
+ * The fallback values for gasLimit and multicallChunk if any failures occur.
+ *
+ */
+export declare type FailureOverrides = {
+    multicallChunk: number;
+    gasLimitOverride: number;
+};
+export declare type BlockHeaderFailureOverridesDisabled = {
+    enabled: false;
+};
+export declare type BlockHeaderFailureOverridesEnabled = {
+    enabled: true;
+    rollbackBlockOffset: number;
+    attemptsBeforeRollback: number;
+};
+export declare type BlockHeaderFailureOverrides = BlockHeaderFailureOverridesDisabled | BlockHeaderFailureOverridesEnabled;
+/**
+ * Config around what block number to query and how to handle failures due to block header errors.
+ */
+export declare type BlockNumberConfig = {
+    baseBlockOffset: number;
+    rollback: BlockHeaderFailureOverrides;
+};
+/**
+ * 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 declare class OnChainQuoteProvider implements IOnChainQuoteProvider {
+    protected chainId: ChainId;
+    protected provider: BaseProvider;
+    protected multicall2Provider: UniswapMulticallProvider;
+    protected retryOptions: QuoteRetryOptions;
+    protected batchParams: (optimisticCachedRoutes: boolean, useMixedRouteQuoter: boolean) => BatchParams;
+    protected gasErrorFailureOverride: FailureOverrides;
+    protected successRateFailureOverrides: FailureOverrides;
+    protected blockNumberConfig: BlockNumberConfig;
+    protected quoterAddressOverride?: ((useMixedRouteQuoter: boolean, mixedRouteContainsV4Pool: boolean, protocol: Protocol) => string | undefined) | undefined;
+    protected metricsPrefix: (chainId: ChainId, useMixedRouteQuoter: boolean, optimisticCachedRoutes: boolean) => string;
+    /**
+     * 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: ChainId, provider: BaseProvider, multicall2Provider: UniswapMulticallProvider, retryOptions?: QuoteRetryOptions, batchParams?: (optimisticCachedRoutes: boolean, useMixedRouteQuoter: boolean) => BatchParams, gasErrorFailureOverride?: FailureOverrides, successRateFailureOverrides?: FailureOverrides, blockNumberConfig?: BlockNumberConfig, quoterAddressOverride?: ((useMixedRouteQuoter: boolean, mixedRouteContainsV4Pool: boolean, protocol: Protocol) => string | undefined) | undefined, metricsPrefix?: (chainId: ChainId, useMixedRouteQuoter: boolean, optimisticCachedRoutes: boolean) => string);
+    private getQuoterAddress;
+    getQuotesManyExactIn<TRoute extends SupportedRoutes>(amountIns: CurrencyAmount[], routes: TRoute[], providerConfig?: ProviderConfig): Promise<OnChainQuotes<TRoute>>;
+    getQuotesManyExactOut<TRoute extends SupportedExactOutRoutes>(amountOuts: CurrencyAmount[], routes: TRoute[], providerConfig?: ProviderConfig): Promise<OnChainQuotes<TRoute>>;
+    private encodeRouteToPath;
+    private getContractInterface;
+    private consolidateResults;
+    private getQuotesManyData;
+    private partitionQuotes;
+    private processQuoteResults;
+    private validateBlockNumbers;
+    protected validateSuccessRate(allResults: Result<[BigNumber, BigNumber[], number[], BigNumber]>[], haveRetriedForSuccessRate: boolean, useMixedRouteQuoter: boolean, optimisticCachedRoutes: boolean): void | SuccessRateError;
+    /**
+     * 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
+     */
+    protected validateRoutes(routes: SupportedRoutes[], functionName: string, useMixedRouteQuoter: boolean): void;
+}
+export {};