@synthra-swap/smart-order-router 3.15.0

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

@@ -0,0 +1,116 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '@synthra-swap/sdk-core';
+import { AAVE_MAINNET, LIDO_MAINNET } from '../../../../providers';
+// 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.GOERLI:
+        case ChainId.SEPOLIA:
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.BNB:
+        case ChainId.AVALANCHE:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+            return BigNumber.from(2000);
+        case ChainId.ARBITRUM_ONE:
+        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.UOMI:
+            return BigNumber.from(2000);
+    }
+};
+export const COST_PER_INIT_TICK = (id) => {
+    switch (id) {
+        case ChainId.MAINNET:
+        case ChainId.GOERLI:
+        case ChainId.SEPOLIA:
+        case ChainId.BNB:
+        case ChainId.AVALANCHE:
+            return BigNumber.from(31000);
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+            return BigNumber.from(31000);
+        case ChainId.ARBITRUM_ONE:
+        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.UOMI:
+            return BigNumber.from(31000);
+    }
+};
+export const COST_PER_HOP = (id) => {
+    switch (id) {
+        case ChainId.MAINNET:
+        case ChainId.GOERLI:
+        case ChainId.SEPOLIA:
+        case ChainId.BNB:
+        case ChainId.OPTIMISM:
+        case ChainId.OPTIMISM_GOERLI:
+        case ChainId.AVALANCHE:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+            return BigNumber.from(80000);
+        case ChainId.ARBITRUM_ONE:
+        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.UOMI:
+            return BigNumber.from(80000);
+    }
+};
+export const SINGLE_HOP_OVERHEAD = (_id) => {
+    return BigNumber.from(15000);
+};
+export const TOKEN_OVERHEAD = (id, route) => {
+    const tokens = route.tokenPath;
+    let overhead = BigNumber.from(0);
+    if (id == ChainId.MAINNET) {
+        // AAVE's transfer contains expensive governance snapshotting logic. We estimate
+        // it at around 150k.
+        if (tokens.some((t) => t.equals(AAVE_MAINNET))) {
+            overhead = overhead.add(150000);
+        }
+        // LDO's reaches out to an external token controller which adds a large overhead
+        // of around 150k.
+        if (tokens.some((t) => t.equals(LIDO_MAINNET))) {
+            overhead = overhead.add(150000);
+        }
+    }
+    return overhead;
+};
+//# 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, pools, 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,293 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId, Percent, Price, TradeType } from '@synthra-swap/sdk-core';
+import _ from 'lodash';
+import { SwapType, WRAPPED_NATIVE_CURRENCY, } from '../../../..';
+import { CurrencyAmount } from '../../../../util/amounts';
+import { 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, SINGLE_HOP_OVERHEAD, TOKEN_OVERHEAD, } 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, pools, amountToken, quoteToken, l2GasDataProvider, }) {
+        const l2GasData = l2GasDataProvider
+            ? await l2GasDataProvider.getGasData()
+            : undefined;
+        const usdPool = pools.usdPool;
+        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);
+            const opStackChains = [
+                ChainId.OPTIMISM,
+                ChainId.OPTIMISM_GOERLI,
+                ChainId.BASE,
+                ChainId.BASE_GOERLI,
+            ];
+            if (opStackChains.includes(chainId)) {
+                [l1Used, l1FeeInWei] = this.calculateOptimismToL1SecurityFee(route, swapOptions, l2GasData);
+            }
+            else if (chainId == ChainId.ARBITRUM_ONE ||
+                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 = pools.nativeQuoteTokenV3Pool;
+                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 = pools.nativeQuoteTokenV3Pool;
+        let nativeAmountPool = null;
+        if (!amountToken.equals(nativeCurrency)) {
+            nativeAmountPool = pools.nativeAmountTokenV3Pool;
+        }
+        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);
+        let hopsGasUse = COST_PER_HOP(chainId).mul(totalHops);
+        // We have observed that this algorithm tends to underestimate single hop swaps.
+        // We add a buffer in the case of a single hop swap.
+        if (totalHops.eq(1)) {
+            hopsGasUse = hopsGasUse.add(SINGLE_HOP_OVERHEAD(chainId));
+        }
+        // Some tokens have extremely expensive transferFrom functions, which causes
+        // us to underestimate them by a large amount. For known tokens, we apply an
+        // adjustment.
+        const tokenOverhead = TOKEN_OVERHEAD(chainId, routeWithValidQuote.route);
+        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(tokenOverhead)
+            .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 { Pair } from '@uniswap/v2-sdk';
+import { Pool } from '@uniswap/v3-sdk';
+import { Currency, Token, TradeType } from '@synthra-swap/sdk-core';
+import { ITokenListProvider, ITokenProvider, ITokenValidatorProvider, TokenValidationResult } from '../../../providers';
+import { CurrencyAmount, SupportedIds } 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: SupportedIds;
+    protected blockedTokenListProvider?: ITokenListProvider;
+    protected tokenValidatorProvider?: ITokenValidatorProvider;
+    constructor(tokenProvider: ITokenProvider, chainId: SupportedIds, 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,53 @@
+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=