v-swap-smart-order-router 3.10.2

package/build/module/routers/alpha-router/gas-models/v3/gas-costs.js

@@ -0,0 +1,104 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '../../../..';
+// Cost for crossing an uninitialized tick.
+export const COST_PER_UNINIT_TICK = BigNumber.from(0);
+//l2 execution fee on optimism is roughly the same as mainnet
+export const BASE_SWAP_COST = (id) => {
+    switch (id) {
+        case ChainId.MAINNET:
+        case ChainId.ROPSTEN:
+        case ChainId.RINKEBY:
+        case ChainId.GÖRLI:
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.OPTIMISTIC_KOVAN:
+        case ChainId.BSC:
+        case ChainId.KOVAN:
+            return BigNumber.from(2000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_RINKEBY:
+        case ChainId.ARBITRUM_GOERLI:
+            return BigNumber.from(5000);
+        case ChainId.POLYGON:
+        case ChainId.POLYGON_MUMBAI:
+            return BigNumber.from(2000);
+        case ChainId.CELO:
+        case ChainId.CELO_ALFAJORES:
+            return BigNumber.from(2000);
+        //TODO determine if sufficient
+        case ChainId.GNOSIS:
+            return BigNumber.from(2000);
+        case ChainId.MOONBEAM:
+            return BigNumber.from(2000);
+        case ChainId.CFX:
+            return BigNumber.from(4000);
+        case ChainId.CFX_TEST:
+            return BigNumber.from(4000);
+    }
+};
+export const COST_PER_INIT_TICK = (id) => {
+    switch (id) {
+        case ChainId.MAINNET:
+        case ChainId.ROPSTEN:
+        case ChainId.RINKEBY:
+        case ChainId.GÖRLI:
+        case ChainId.BSC:
+        case ChainId.KOVAN:
+            return BigNumber.from(31000);
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.OPTIMISTIC_KOVAN:
+            return BigNumber.from(31000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_RINKEBY:
+        case ChainId.ARBITRUM_GOERLI:
+            return BigNumber.from(31000);
+        case ChainId.POLYGON:
+        case ChainId.POLYGON_MUMBAI:
+            return BigNumber.from(31000);
+        case ChainId.CELO:
+        case ChainId.CELO_ALFAJORES:
+            return BigNumber.from(31000);
+        case ChainId.GNOSIS:
+            return BigNumber.from(31000);
+        case ChainId.MOONBEAM:
+            return BigNumber.from(31000);
+        case ChainId.CFX:
+            return BigNumber.from(62000);
+        case ChainId.CFX_TEST:
+            return BigNumber.from(62000);
+    }
+};
+export const COST_PER_HOP = (id) => {
+    switch (id) {
+        case ChainId.MAINNET:
+        case ChainId.ROPSTEN:
+        case ChainId.RINKEBY:
+        case ChainId.GÖRLI:
+        case ChainId.KOVAN:
+        case ChainId.BSC:
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.OPTIMISTIC_KOVAN:
+            return BigNumber.from(80000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_RINKEBY:
+        case ChainId.ARBITRUM_GOERLI:
+            return BigNumber.from(80000);
+        case ChainId.POLYGON:
+        case ChainId.POLYGON_MUMBAI:
+            return BigNumber.from(80000);
+        case ChainId.CELO:
+        case ChainId.CELO_ALFAJORES:
+            return BigNumber.from(80000);
+        case ChainId.GNOSIS:
+            return BigNumber.from(80000);
+        case ChainId.MOONBEAM:
+            return BigNumber.from(80000);
+        case ChainId.CFX:
+            return BigNumber.from(160000);
+        case ChainId.CFX_TEST:
+            return BigNumber.from(160000);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/routers/alpha-router/gas-models/v3/v3-heuristic-gas-model.d.ts

@@ -0,0 +1,31 @@
+import { V3RouteWithValidQuote } from '../../entities/route-with-valid-quote';
+import { BuildOnChainGasModelFactoryType, IGasModel, IOnChainGasModelFactory } from '../gas-model';
+/**
+ * Computes a gas estimate for a V3 swap using heuristics.
+ * Considers number of hops in the route, number of ticks crossed
+ * and the typical base cost for a swap.
+ *
+ * We get the number of ticks crossed in a swap from the QuoterV2
+ * contract.
+ *
+ * We compute gas estimates off-chain because
+ *  1/ Calling eth_estimateGas for a swaps requires the caller to have
+ *     the full balance token being swapped, and approvals.
+ *  2/ Tracking gas used using a wrapper contract is not accurate with Multicall
+ *     due to EIP-2929. We would have to make a request for every swap we wanted to estimate.
+ *  3/ For V2 we simulate all our swaps off-chain so have no way to track gas used.
+ *
+ * @export
+ * @class V3HeuristicGasModelFactory
+ */
+export declare class V3HeuristicGasModelFactory extends IOnChainGasModelFactory {
+    constructor();
+    buildGasModel({ chainId, gasPriceWei, v3poolProvider: poolProvider, amountToken, quoteToken, l2GasDataProvider, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<V3RouteWithValidQuote>>;
+    private estimateGas;
+    /**
+     * To avoid having a call to optimism's L1 security fee contract for every route and amount combination,
+     * we replicate the gas cost accounting here.
+     */
+    private calculateOptimismToL1SecurityFee;
+    private calculateArbitrumToL1SecurityFee;
+}

package/build/module/routers/alpha-router/gas-models/v3/v3-heuristic-gas-model.js

@@ -0,0 +1,281 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Percent, Price, TradeType } from '@uniswap/sdk-core';
+import _ from 'lodash';
+import { SwapType, WRAPPED_NATIVE_CURRENCY, } from '../../../..';
+import { ChainId } from '../../../../util';
+import { CurrencyAmount } from '../../../../util/amounts';
+import { getHighestLiquidityV3NativePool, getHighestLiquidityV3USDPool, getL2ToL1GasUsed, } from '../../../../util/gas-factory-helpers';
+import { log } from '../../../../util/log';
+import { buildSwapMethodParameters, buildTrade, } from '../../../../util/methodParameters';
+import { IOnChainGasModelFactory, } from '../gas-model';
+import { BASE_SWAP_COST, COST_PER_HOP, COST_PER_INIT_TICK, COST_PER_UNINIT_TICK, } from './gas-costs';
+/**
+ * Computes a gas estimate for a V3 swap using heuristics.
+ * Considers number of hops in the route, number of ticks crossed
+ * and the typical base cost for a swap.
+ *
+ * We get the number of ticks crossed in a swap from the QuoterV2
+ * contract.
+ *
+ * We compute gas estimates off-chain because
+ *  1/ Calling eth_estimateGas for a swaps requires the caller to have
+ *     the full balance token being swapped, and approvals.
+ *  2/ Tracking gas used using a wrapper contract is not accurate with Multicall
+ *     due to EIP-2929. We would have to make a request for every swap we wanted to estimate.
+ *  3/ For V2 we simulate all our swaps off-chain so have no way to track gas used.
+ *
+ * @export
+ * @class V3HeuristicGasModelFactory
+ */
+export class V3HeuristicGasModelFactory extends IOnChainGasModelFactory {
+    constructor() {
+        super();
+    }
+    async buildGasModel({ chainId, gasPriceWei, v3poolProvider: poolProvider, amountToken, quoteToken, l2GasDataProvider, }) {
+        const l2GasData = l2GasDataProvider
+            ? await l2GasDataProvider.getGasData()
+            : undefined;
+        const usdPool = await getHighestLiquidityV3USDPool(chainId, poolProvider);
+        const calculateL1GasFees = async (route) => {
+            const swapOptions = {
+                type: SwapType.UNIVERSAL_ROUTER,
+                recipient: '0x0000000000000000000000000000000000000001',
+                deadlineOrPreviousBlockhash: 100,
+                slippageTolerance: new Percent(5, 10000),
+            };
+            let l1Used = BigNumber.from(0);
+            let l1FeeInWei = BigNumber.from(0);
+            if (chainId == ChainId.OPTIMISM ||
+                chainId == ChainId.OPTIMISTIC_KOVAN ||
+                chainId == ChainId.OPTIMISM_GOERLI) {
+                [l1Used, l1FeeInWei] = this.calculateOptimismToL1SecurityFee(route, swapOptions, l2GasData);
+            }
+            else if (chainId == ChainId.ARBITRUM_ONE ||
+                chainId == ChainId.ARBITRUM_RINKEBY ||
+                chainId == ChainId.ARBITRUM_GOERLI) {
+                [l1Used, l1FeeInWei] = this.calculateArbitrumToL1SecurityFee(route, swapOptions, l2GasData);
+            }
+            // wrap fee to native currency
+            const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+            const costNativeCurrency = CurrencyAmount.fromRawAmount(nativeCurrency, l1FeeInWei.toString());
+            // convert fee into usd
+            const nativeTokenPrice = usdPool.token0.address == nativeCurrency.address
+                ? usdPool.token0Price
+                : usdPool.token1Price;
+            const gasCostL1USD = nativeTokenPrice.quote(costNativeCurrency);
+            let gasCostL1QuoteToken = costNativeCurrency;
+            // if the inputted token is not in the native currency, quote a native/quote token pool to get the gas cost in terms of the quote token
+            if (!quoteToken.equals(nativeCurrency)) {
+                const nativePool = await getHighestLiquidityV3NativePool(quoteToken, poolProvider);
+                if (!nativePool) {
+                    log.info('Could not find a pool to convert the cost into the quote token');
+                    gasCostL1QuoteToken = CurrencyAmount.fromRawAmount(quoteToken, 0);
+                }
+                else {
+                    const nativeTokenPrice = nativePool.token0.address == nativeCurrency.address
+                        ? nativePool.token0Price
+                        : nativePool.token1Price;
+                    gasCostL1QuoteToken = nativeTokenPrice.quote(costNativeCurrency);
+                }
+            }
+            // gasUsedL1 is the gas units used calculated from the bytes of the calldata
+            // gasCostL1USD and gasCostL1QuoteToken is the cost of gas in each of those tokens
+            return {
+                gasUsedL1: l1Used,
+                gasCostL1USD,
+                gasCostL1QuoteToken,
+            };
+        };
+        // If our quote token is WETH, we don't need to convert our gas use to be in terms
+        // of the quote token in order to produce a gas adjusted amount.
+        // We do return a gas use in USD however, so we still convert to usd.
+        const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+        if (quoteToken.equals(nativeCurrency)) {
+            const estimateGasCost = (routeWithValidQuote) => {
+                const { totalGasCostNativeCurrency, baseGasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId);
+                const token0 = usdPool.token0.address == nativeCurrency.address;
+                const nativeTokenPrice = token0
+                    ? usdPool.token0Price
+                    : usdPool.token1Price;
+                const gasCostInTermsOfUSD = nativeTokenPrice.quote(totalGasCostNativeCurrency);
+                return {
+                    gasEstimate: baseGasUse,
+                    gasCostInToken: totalGasCostNativeCurrency,
+                    gasCostInUSD: gasCostInTermsOfUSD,
+                };
+            };
+            return {
+                estimateGasCost,
+                calculateL1GasFees,
+            };
+        }
+        // If the quote token is not in the native currency, we convert the gas cost to be in terms of the quote token.
+        // We do this by getting the highest liquidity <quoteToken>/<nativeCurrency> pool. eg. <quoteToken>/ETH pool.
+        const nativePool = await getHighestLiquidityV3NativePool(quoteToken, poolProvider);
+        let nativeAmountPool = null;
+        if (!amountToken.equals(nativeCurrency)) {
+            nativeAmountPool = await getHighestLiquidityV3NativePool(amountToken, poolProvider);
+        }
+        const usdToken = usdPool.token0.address == nativeCurrency.address
+            ? usdPool.token1
+            : usdPool.token0;
+        const estimateGasCost = (routeWithValidQuote) => {
+            const { totalGasCostNativeCurrency, baseGasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId);
+            let gasCostInTermsOfQuoteToken = null;
+            if (nativePool) {
+                const token0 = nativePool.token0.address == nativeCurrency.address;
+                // returns mid price in terms of the native currency (the ratio of quoteToken/nativeToken)
+                const nativeTokenPrice = token0
+                    ? nativePool.token0Price
+                    : nativePool.token1Price;
+                try {
+                    // native token is base currency
+                    gasCostInTermsOfQuoteToken = nativeTokenPrice.quote(totalGasCostNativeCurrency);
+                }
+                catch (err) {
+                    log.info({
+                        nativeTokenPriceBase: nativeTokenPrice.baseCurrency,
+                        nativeTokenPriceQuote: nativeTokenPrice.quoteCurrency,
+                        gasCostInEth: totalGasCostNativeCurrency.currency,
+                    }, 'Debug eth price token issue');
+                    throw err;
+                }
+            }
+            // we have a nativeAmountPool, but not a nativePool
+            else {
+                log.info(`Unable to find ${nativeCurrency.symbol} pool with the quote token, ${quoteToken.symbol} to produce gas adjusted costs. Using amountToken to calculate gas costs.`);
+            }
+            // Highest liquidity pool for the non quote token / ETH
+            // A pool with the non quote token / ETH should not be required and errors should be handled separately
+            if (nativeAmountPool) {
+                // get current execution price (amountToken / quoteToken)
+                const executionPrice = new Price(routeWithValidQuote.amount.currency, routeWithValidQuote.quote.currency, routeWithValidQuote.amount.quotient, routeWithValidQuote.quote.quotient);
+                const inputIsToken0 = nativeAmountPool.token0.address == nativeCurrency.address;
+                // ratio of input / native
+                const nativeAmountTokenPrice = inputIsToken0
+                    ? nativeAmountPool.token0Price
+                    : nativeAmountPool.token1Price;
+                const gasCostInTermsOfAmountToken = nativeAmountTokenPrice.quote(totalGasCostNativeCurrency);
+                // Convert gasCostInTermsOfAmountToken to quote token using execution price
+                const syntheticGasCostInTermsOfQuoteToken = executionPrice.quote(gasCostInTermsOfAmountToken);
+                // Note that the syntheticGasCost being lessThan the original quoted value is not always strictly better
+                // e.g. the scenario where the amountToken/ETH pool is very illiquid as well and returns an extremely small number
+                // however, it is better to have the gasEstimation be almost 0 than almost infinity, as the user will still receive a quote
+                if (gasCostInTermsOfQuoteToken === null ||
+                    syntheticGasCostInTermsOfQuoteToken.lessThan(gasCostInTermsOfQuoteToken.asFraction)) {
+                    log.info({
+                        nativeAmountTokenPrice: nativeAmountTokenPrice.toSignificant(6),
+                        gasCostInTermsOfQuoteToken: gasCostInTermsOfQuoteToken
+                            ? gasCostInTermsOfQuoteToken.toExact()
+                            : 0,
+                        gasCostInTermsOfAmountToken: gasCostInTermsOfAmountToken.toExact(),
+                        executionPrice: executionPrice.toSignificant(6),
+                        syntheticGasCostInTermsOfQuoteToken: syntheticGasCostInTermsOfQuoteToken.toSignificant(6),
+                    }, 'New gasCostInTermsOfQuoteToken calculated with synthetic quote token price is less than original');
+                    gasCostInTermsOfQuoteToken = syntheticGasCostInTermsOfQuoteToken;
+                }
+            }
+            // true if token0 is the native currency
+            const token0USDPool = usdPool.token0.address == nativeCurrency.address;
+            // gets the mid price of the pool in terms of the native token
+            const nativeTokenPriceUSDPool = token0USDPool
+                ? usdPool.token0Price
+                : usdPool.token1Price;
+            let gasCostInTermsOfUSD;
+            try {
+                gasCostInTermsOfUSD = nativeTokenPriceUSDPool.quote(totalGasCostNativeCurrency);
+            }
+            catch (err) {
+                log.info({
+                    usdT1: usdPool.token0.symbol,
+                    usdT2: usdPool.token1.symbol,
+                    gasCostInNativeToken: totalGasCostNativeCurrency.currency.symbol,
+                }, 'Failed to compute USD gas price');
+                throw err;
+            }
+            // If gasCostInTermsOfQuoteToken is null, both attempts to calculate gasCostInTermsOfQuoteToken failed (nativePool and amountNativePool)
+            if (gasCostInTermsOfQuoteToken === null) {
+                log.info(`Unable to find ${nativeCurrency.symbol} pool with the quote token, ${quoteToken.symbol}, or amount Token, ${amountToken.symbol} to produce gas adjusted costs. Route will not account for gas.`);
+                return {
+                    gasEstimate: baseGasUse,
+                    gasCostInToken: CurrencyAmount.fromRawAmount(quoteToken, 0),
+                    gasCostInUSD: CurrencyAmount.fromRawAmount(usdToken, 0),
+                };
+            }
+            return {
+                gasEstimate: baseGasUse,
+                gasCostInToken: gasCostInTermsOfQuoteToken,
+                gasCostInUSD: gasCostInTermsOfUSD,
+            };
+        };
+        return {
+            estimateGasCost: estimateGasCost.bind(this),
+            calculateL1GasFees,
+        };
+    }
+    estimateGas(routeWithValidQuote, gasPriceWei, chainId) {
+        const totalInitializedTicksCrossed = BigNumber.from(Math.max(1, _.sum(routeWithValidQuote.initializedTicksCrossedList)));
+        const totalHops = BigNumber.from(routeWithValidQuote.route.pools.length);
+        const hopsGasUse = COST_PER_HOP(chainId).mul(totalHops);
+        const tickGasUse = COST_PER_INIT_TICK(chainId).mul(totalInitializedTicksCrossed);
+        const uninitializedTickGasUse = COST_PER_UNINIT_TICK.mul(0);
+        // base estimate gas used based on chainId estimates for hops and ticks gas useage
+        const baseGasUse = BASE_SWAP_COST(chainId)
+            .add(hopsGasUse)
+            .add(tickGasUse)
+            .add(uninitializedTickGasUse);
+        const baseGasCostWei = gasPriceWei.mul(baseGasUse);
+        const wrappedCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+        const totalGasCostNativeCurrency = CurrencyAmount.fromRawAmount(wrappedCurrency, baseGasCostWei.toString());
+        return {
+            totalGasCostNativeCurrency,
+            totalInitializedTicksCrossed,
+            baseGasUse,
+        };
+    }
+    /**
+     * To avoid having a call to optimism's L1 security fee contract for every route and amount combination,
+     * we replicate the gas cost accounting here.
+     */
+    calculateOptimismToL1SecurityFee(routes, swapConfig, gasData) {
+        const { l1BaseFee, scalar, decimals, overhead } = gasData;
+        const route = routes[0];
+        const amountToken = route.tradeType == TradeType.EXACT_INPUT
+            ? route.amount.currency
+            : route.quote.currency;
+        const outputToken = route.tradeType == TradeType.EXACT_INPUT
+            ? route.quote.currency
+            : route.amount.currency;
+        // build trade for swap calldata
+        const trade = buildTrade(amountToken, outputToken, route.tradeType, routes);
+        const data = buildSwapMethodParameters(trade, swapConfig, ChainId.OPTIMISM).calldata;
+        const l1GasUsed = getL2ToL1GasUsed(data, overhead);
+        // l1BaseFee is L1 Gas Price on etherscan
+        const l1Fee = l1GasUsed.mul(l1BaseFee);
+        const unscaled = l1Fee.mul(scalar);
+        // scaled = unscaled / (10 ** decimals)
+        const scaledConversion = BigNumber.from(10).pow(decimals);
+        const scaled = unscaled.div(scaledConversion);
+        return [l1GasUsed, scaled];
+    }
+    calculateArbitrumToL1SecurityFee(routes, swapConfig, gasData) {
+        const { perL2TxFee, perL1CalldataFee } = gasData;
+        const route = routes[0];
+        const amountToken = route.tradeType == TradeType.EXACT_INPUT
+            ? route.amount.currency
+            : route.quote.currency;
+        const outputToken = route.tradeType == TradeType.EXACT_INPUT
+            ? route.quote.currency
+            : route.amount.currency;
+        // build trade for swap calldata
+        const trade = buildTrade(amountToken, outputToken, route.tradeType, routes);
+        const data = buildSwapMethodParameters(trade, swapConfig, ChainId.ARBITRUM_ONE).calldata;
+        // calculates gas amounts based on bytes of calldata, use 0 as overhead.
+        const l1GasUsed = getL2ToL1GasUsed(data, BigNumber.from(0));
+        // multiply by the fee per calldata and add the flat l2 fee
+        let l1Fee = l1GasUsed.mul(perL1CalldataFee);
+        l1Fee = l1Fee.add(perL2TxFee);
+        return [l1GasUsed, l1Fee];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v3-heuristic-gas-model.js","sourceRoot":"","sources":["../../../../../../src/routers/alpha-router/gas-models/v3/v3-heuristic-gas-model.ts"],"names":[],"mappings":"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"}

package/build/module/routers/alpha-router/index.d.ts

@@ -0,0 +1,4 @@
+export * from './alpha-router';
+export * from './entities';
+export * from './gas-models';
+export * from './quoters';

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

@@ -0,0 +1,5 @@
+export * from './alpha-router';
+export * from './entities';
+export * from './gas-models';
+export * from './quoters';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcm91dGVycy9hbHBoYS1yb3V0ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQyJ9

package/build/module/routers/alpha-router/quoters/base-quoter.d.ts

@@ -0,0 +1,68 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Currency, Token, TradeType } from '@uniswap/sdk-core';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool } from '@uniswap/v3-sdk';
+import { ITokenListProvider, ITokenProvider, ITokenValidatorProvider, TokenValidationResult } from '../../../providers';
+import { ChainId, CurrencyAmount } from '../../../util';
+import { MixedRoute, V2Route, V3Route } from '../../router';
+import { AlphaRouterConfig } from '../alpha-router';
+import { RouteWithValidQuote } from '../entities/route-with-valid-quote';
+import { CandidatePoolsBySelectionCriteria } from '../functions/get-candidate-pools';
+import { IGasModel } from '../gas-models';
+import { GetQuotesResult, GetRoutesResult } from './model/results';
+/**
+ * Interface for a Quoter.
+ * Defines the base dependencies, helper methods and interface for how to fetch quotes.
+ *
+ * @abstract
+ * @template Route
+ */
+export declare abstract class BaseQuoter<Route extends V2Route | V3Route | MixedRoute> {
+    protected tokenProvider: ITokenProvider;
+    protected chainId: ChainId;
+    protected blockedTokenListProvider?: ITokenListProvider;
+    protected tokenValidatorProvider?: ITokenValidatorProvider;
+    constructor(tokenProvider: ITokenProvider, chainId: ChainId, blockedTokenListProvider?: ITokenListProvider, tokenValidatorProvider?: ITokenValidatorProvider);
+    /**
+     * Protected method in charge of fetching the routes for the tokenIn/tokenOut pair.
+     *
+     * @protected
+     * @abstract
+     * @param tokenIn The token that the user wants to provide
+     * @param tokenOut The token that the usaw wants to receive
+     * @param tradeType The type of quote the user wants. He could want to provide exactly X tokenIn or receive exactly X tokenOut
+     * @param routingConfig
+     * @returns Promise<GetRoutesResult<Route>>
+     */
+    protected abstract getRoutes(tokenIn: Token, tokenOut: Token, tradeType: TradeType, routingConfig: AlphaRouterConfig): Promise<GetRoutesResult<Route>>;
+    /**
+     * Public method that will fetch quotes for the combination of every route and every amount.
+     *
+     * @param routes the list of route that can be used to fetch a quote.
+     * @param amounts the list of amounts to query for EACH route.
+     * @param percents the percentage of each amount.
+     * @param quoteToken
+     * @param tradeType
+     * @param routingConfig
+     * @param candidatePools the candidate pools that were used to generate the routes
+     * @param gasModel the gasModel to be used for estimating gas cost
+     * @param gasPriceWei instead of passing gasModel, gasPriceWei is used to generate a gasModel
+     * @returns Promise<GetQuotesResult<Route>>
+     */
+    abstract getQuotes(routes: Route[], amounts: CurrencyAmount[], percents: number[], quoteToken: Token, tradeType: TradeType, routingConfig: AlphaRouterConfig, candidatePools?: CandidatePoolsBySelectionCriteria, gasModel?: IGasModel<RouteWithValidQuote>, gasPriceWei?: BigNumber): Promise<GetQuotesResult>;
+    /**
+     * Public method which would first get the routes and then get the quotes.
+     *
+     * @param tokenIn The token that the user wants to provide
+     * @param tokenOut The token that the usaw wants to receive
+     * @param amounts the list of amounts to query for EACH route.
+     * @param percents the percentage of each amount.
+     * @param quoteToken
+     * @param tradeType
+     * @param routingConfig
+     * @param gasModel the gasModel to be used for estimating gas cost
+     * @param gasPriceWei instead of passing gasModel, gasPriceWei is used to generate a gasModel
+     */
+    getRoutesThenQuotes(tokenIn: Token, tokenOut: Token, amounts: CurrencyAmount[], percents: number[], quoteToken: Token, tradeType: TradeType, routingConfig: AlphaRouterConfig, gasModel?: IGasModel<RouteWithValidQuote>, gasPriceWei?: BigNumber): Promise<GetQuotesResult>;
+    protected applyTokenValidatorToPools<T extends Pool | Pair>(pools: T[], isInvalidFn: (token: Currency, tokenValidation: TokenValidationResult | undefined) => boolean): Promise<T[]>;
+}

package/build/module/routers/alpha-router/quoters/base-quoter.js

@@ -0,0 +1,54 @@
+import _ from 'lodash';
+import { log, poolToString } from '../../../util';
+/**
+ * Interface for a Quoter.
+ * Defines the base dependencies, helper methods and interface for how to fetch quotes.
+ *
+ * @abstract
+ * @template Route
+ */
+export class BaseQuoter {
+    constructor(tokenProvider, chainId, blockedTokenListProvider, tokenValidatorProvider) {
+        this.tokenProvider = tokenProvider;
+        this.chainId = chainId;
+        this.blockedTokenListProvider = blockedTokenListProvider;
+        this.tokenValidatorProvider = tokenValidatorProvider;
+    }
+    /**
+     * Public method which would first get the routes and then get the quotes.
+     *
+     * @param tokenIn The token that the user wants to provide
+     * @param tokenOut The token that the usaw wants to receive
+     * @param amounts the list of amounts to query for EACH route.
+     * @param percents the percentage of each amount.
+     * @param quoteToken
+     * @param tradeType
+     * @param routingConfig
+     * @param gasModel the gasModel to be used for estimating gas cost
+     * @param gasPriceWei instead of passing gasModel, gasPriceWei is used to generate a gasModel
+     */
+    getRoutesThenQuotes(tokenIn, tokenOut, amounts, percents, quoteToken, tradeType, routingConfig, gasModel, gasPriceWei) {
+        return this.getRoutes(tokenIn, tokenOut, tradeType, routingConfig)
+            .then((routesResult) => this.getQuotes(routesResult.routes, amounts, percents, quoteToken, tradeType, routingConfig, routesResult.candidatePools, gasModel, gasPriceWei));
+    }
+    async applyTokenValidatorToPools(pools, isInvalidFn) {
+        if (!this.tokenValidatorProvider) {
+            return pools;
+        }
+        log.info(`Running token validator on ${pools.length} pools`);
+        const tokens = _.flatMap(pools, (pool) => [pool.token0, pool.token1]);
+        const tokenValidationResults = await this.tokenValidatorProvider.validateTokens(tokens);
+        const poolsFiltered = _.filter(pools, (pool) => {
+            const token0Validation = tokenValidationResults.getValidationByToken(pool.token0);
+            const token1Validation = tokenValidationResults.getValidationByToken(pool.token1);
+            const token0Invalid = isInvalidFn(pool.token0, token0Validation);
+            const token1Invalid = isInvalidFn(pool.token1, token1Validation);
+            if (token0Invalid || token1Invalid) {
+                log.info(`Dropping pool ${poolToString(pool)} because token is invalid. ${pool.token0.symbol}: ${token0Validation}, ${pool.token1.symbol}: ${token1Validation}`);
+            }
+            return !token0Invalid && !token1Invalid;
+        });
+        return poolsFiltered;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/routers/alpha-router/quoters/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model/';
+export * from './base-quoter';
+export * from './v2-quoter';
+export * from './v3-quoter';
+export * from './mixed-quoter';

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

@@ -0,0 +1,6 @@
+export * from './model/';
+export * from './base-quoter';
+export * from './v2-quoter';
+export * from './v3-quoter';
+export * from './mixed-quoter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcm91dGVycy9hbHBoYS1yb3V0ZXIvcXVvdGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDIn0=

package/build/module/routers/alpha-router/quoters/mixed-quoter.d.ts

@@ -0,0 +1,20 @@
+import { Token, TradeType } from '@uniswap/sdk-core';
+import { IOnChainQuoteProvider, ITokenListProvider, ITokenProvider, ITokenValidatorProvider, IV2PoolProvider, IV2SubgraphProvider, IV3PoolProvider, IV3SubgraphProvider } from '../../../providers';
+import { ChainId, CurrencyAmount } from '../../../util';
+import { MixedRoute } from '../../router';
+import { AlphaRouterConfig } from '../alpha-router';
+import { MixedRouteWithValidQuote } from '../entities';
+import { CandidatePoolsBySelectionCriteria } from '../functions/get-candidate-pools';
+import { IGasModel } from '../gas-models';
+import { BaseQuoter } from './base-quoter';
+import { GetQuotesResult, GetRoutesResult } from './model';
+export declare class MixedQuoter extends BaseQuoter<MixedRoute> {
+    protected v3SubgraphProvider: IV3SubgraphProvider;
+    protected v3PoolProvider: IV3PoolProvider;
+    protected v2SubgraphProvider: IV2SubgraphProvider;
+    protected v2PoolProvider: IV2PoolProvider;
+    protected onChainQuoteProvider: IOnChainQuoteProvider;
+    constructor(v3SubgraphProvider: IV3SubgraphProvider, v3PoolProvider: IV3PoolProvider, v2SubgraphProvider: IV2SubgraphProvider, v2PoolProvider: IV2PoolProvider, onChainQuoteProvider: IOnChainQuoteProvider, tokenProvider: ITokenProvider, chainId: ChainId, blockedTokenListProvider?: ITokenListProvider, tokenValidatorProvider?: ITokenValidatorProvider);
+    protected getRoutes(tokenIn: Token, tokenOut: Token, tradeType: TradeType, routingConfig: AlphaRouterConfig): Promise<GetRoutesResult<MixedRoute>>;
+    getQuotes(routes: MixedRoute[], amounts: CurrencyAmount[], percents: number[], quoteToken: Token, tradeType: TradeType, routingConfig: AlphaRouterConfig, candidatePools?: CandidatePoolsBySelectionCriteria, gasModel?: IGasModel<MixedRouteWithValidQuote>): Promise<GetQuotesResult>;
+}