v-swap-smart-order-router 3.10.2

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

@@ -0,0 +1,83 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Token } from '@uniswap/sdk-core';
+import { IV2PoolProvider } from '../../../providers/v2/pool-provider';
+import { ArbitrumGasData, IL2GasDataProvider, OptimismGasData } from '../../../providers/v3/gas-data-provider';
+import { IV3PoolProvider } from '../../../providers/v3/pool-provider';
+import { CurrencyAmount } from '../../../util/amounts';
+import { ChainId } from '../../../util/chains';
+import { MixedRouteWithValidQuote, RouteWithValidQuote, V2RouteWithValidQuote, V3RouteWithValidQuote } from '../entities/route-with-valid-quote';
+export declare const usdGasTokensByChain: {
+    [chainId in ChainId]?: Token[];
+};
+export declare type L1ToL2GasCosts = {
+    gasUsedL1: BigNumber;
+    gasCostL1USD: CurrencyAmount;
+    gasCostL1QuoteToken: CurrencyAmount;
+};
+export declare type BuildOnChainGasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    v3poolProvider: IV3PoolProvider;
+    amountToken: Token;
+    quoteToken: Token;
+    v2poolProvider: IV2PoolProvider;
+    l2GasDataProvider?: IL2GasDataProvider<OptimismGasData> | IL2GasDataProvider<ArbitrumGasData>;
+};
+export declare type BuildV2GasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    poolProvider: IV2PoolProvider;
+    token: Token;
+};
+/**
+ * Contains functions for generating gas estimates for given routes.
+ *
+ * We generally 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
+ *  3/ For V2 we simulate all our swaps off-chain so have no way to track gas used.
+ *
+ * Generally these models should be optimized to return quickly by performing any
+ * long running operations (like fetching external data) outside of the functions defined.
+ * This is because the functions in the model are called once for every route and every
+ * amount that is considered in the algorithm so it is important to minimize the number of
+ * long running operations.
+ */
+export declare type IGasModel<TRouteWithValidQuote extends RouteWithValidQuote> = {
+    estimateGasCost(routeWithValidQuote: TRouteWithValidQuote): {
+        gasEstimate: BigNumber;
+        gasCostInToken: CurrencyAmount;
+        gasCostInUSD: CurrencyAmount;
+    };
+    calculateL1GasFees?(routes: TRouteWithValidQuote[]): Promise<L1ToL2GasCosts>;
+};
+/**
+ * Factory for building gas models that can be used with any route to generate
+ * gas estimates.
+ *
+ * Factory model is used so that any supporting data can be fetched once and
+ * returned as part of the model.
+ *
+ * @export
+ * @abstract
+ * @class IV2GasModelFactory
+ */
+export declare abstract class IV2GasModelFactory {
+    abstract buildGasModel({ chainId, gasPriceWei, poolProvider, token, }: BuildV2GasModelFactoryType): Promise<IGasModel<V2RouteWithValidQuote>>;
+}
+/**
+ * Factory for building gas models that can be used with any route to generate
+ * gas estimates.
+ *
+ * Factory model is used so that any supporting data can be fetched once and
+ * returned as part of the model.
+ *
+ * @export
+ * @abstract
+ * @class IOnChainGasModelFactory
+ */
+export declare abstract class IOnChainGasModelFactory {
+    abstract buildGasModel({ chainId, gasPriceWei, v3poolProvider: V3poolProvider, amountToken, quoteToken, v2poolProvider: V2poolProvider, l2GasDataProvider, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<V3RouteWithValidQuote | MixedRouteWithValidQuote>>;
+}

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

@@ -0,0 +1,67 @@
+import { CUSD_CELO, CUSD_CELO_ALFAJORES, DAI_ARBITRUM, DAI_ARBITRUM_RINKEBY, DAI_BSC, DAI_GÖRLI, DAI_KOVAN, DAI_MAINNET, DAI_OPTIMISM, DAI_OPTIMISM_GOERLI, DAI_OPTIMISTIC_KOVAN, DAI_POLYGON_MUMBAI, DAI_RINKEBY_1, DAI_RINKEBY_2, DAI_ROPSTEN, USDC_ARBITRUM, USDC_ARBITRUM_GOERLI, USDC_BSC, USDC_ETHEREUM_GNOSIS, USDC_GÖRLI, USDC_KOVAN, USDC_MAINNET, USDC_MOONBEAM, USDC_OPTIMISM, USDC_OPTIMISM_GOERLI, USDC_OPTIMISTIC_KOVAN, USDC_POLYGON, USDC_ROPSTEN, USDT_ARBITRUM, USDT_ARBITRUM_RINKEBY, USDT_BSC, USDT_GÖRLI, USDT_KOVAN, USDT_MAINNET, USDT_OPTIMISM, USDT_OPTIMISM_GOERLI, USDT_OPTIMISTIC_KOVAN, USDT_ROPSTEN, WBTC_GÖRLI, USDC_CFX, USDT_CFX, DAI_CFX, 
+//  USDC_CFX_TEST,
+USDT_CFX_TEST,
+//  DAI_CFX_TEST,
+ } from '../../../providers/token-provider';
+import { ChainId } from '../../../util/chains';
+export const usdGasTokensByChain = {
+    [ChainId.MAINNET]: [DAI_MAINNET, USDC_MAINNET, USDT_MAINNET],
+    [ChainId.RINKEBY]: [DAI_RINKEBY_1, DAI_RINKEBY_2],
+    [ChainId.ARBITRUM_ONE]: [DAI_ARBITRUM, USDC_ARBITRUM, USDT_ARBITRUM],
+    [ChainId.OPTIMISM]: [DAI_OPTIMISM, USDC_OPTIMISM, USDT_OPTIMISM],
+    [ChainId.OPTIMISM_GOERLI]: [
+        DAI_OPTIMISM_GOERLI,
+        USDC_OPTIMISM_GOERLI,
+        USDT_OPTIMISM_GOERLI,
+    ],
+    [ChainId.OPTIMISTIC_KOVAN]: [
+        DAI_OPTIMISTIC_KOVAN,
+        USDC_OPTIMISTIC_KOVAN,
+        USDT_OPTIMISTIC_KOVAN,
+    ],
+    [ChainId.ARBITRUM_RINKEBY]: [DAI_ARBITRUM_RINKEBY, USDT_ARBITRUM_RINKEBY],
+    [ChainId.ARBITRUM_GOERLI]: [USDC_ARBITRUM_GOERLI],
+    [ChainId.KOVAN]: [DAI_KOVAN, USDC_KOVAN, USDT_KOVAN],
+    [ChainId.GÖRLI]: [DAI_GÖRLI, USDC_GÖRLI, USDT_GÖRLI, WBTC_GÖRLI],
+    [ChainId.ROPSTEN]: [DAI_ROPSTEN, USDC_ROPSTEN, USDT_ROPSTEN],
+    [ChainId.POLYGON]: [USDC_POLYGON],
+    [ChainId.POLYGON_MUMBAI]: [DAI_POLYGON_MUMBAI],
+    [ChainId.CELO]: [CUSD_CELO],
+    [ChainId.CELO_ALFAJORES]: [CUSD_CELO_ALFAJORES],
+    [ChainId.GNOSIS]: [USDC_ETHEREUM_GNOSIS],
+    [ChainId.MOONBEAM]: [USDC_MOONBEAM],
+    [ChainId.BSC]: [USDT_BSC, USDC_BSC, DAI_BSC],
+    [ChainId.CFX]: [USDT_CFX, USDC_CFX, DAI_CFX],
+    [ChainId.CFX_TEST]: [
+        USDT_CFX_TEST,
+        //    USDC_CFX_TEST,
+        //    DAI_CFX_TEST
+    ],
+};
+/**
+ * Factory for building gas models that can be used with any route to generate
+ * gas estimates.
+ *
+ * Factory model is used so that any supporting data can be fetched once and
+ * returned as part of the model.
+ *
+ * @export
+ * @abstract
+ * @class IV2GasModelFactory
+ */
+export class IV2GasModelFactory {
+}
+/**
+ * Factory for building gas models that can be used with any route to generate
+ * gas estimates.
+ *
+ * Factory model is used so that any supporting data can be fetched once and
+ * returned as part of the model.
+ *
+ * @export
+ * @abstract
+ * @class IOnChainGasModelFactory
+ */
+export class IOnChainGasModelFactory {
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export * from './gas-model';
+export * from './v3/v3-heuristic-gas-model';

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

@@ -0,0 +1,3 @@
+export * from './gas-model';
+export * from './v3/v3-heuristic-gas-model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcm91dGVycy9hbHBoYS1yb3V0ZXIvZ2FzLW1vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLDZCQUE2QixDQUFDIn0=

package/build/module/routers/alpha-router/gas-models/mixedRoute/mixed-route-heuristic-gas-model.d.ts

@@ -0,0 +1,25 @@
+import { MixedRouteWithValidQuote } from '../../entities/route-with-valid-quote';
+import { BuildOnChainGasModelFactoryType, IGasModel, IOnChainGasModelFactory } from '../gas-model';
+/**
+ * Computes a gas estimate for a mixed route 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 MixedRouteQuoterV1
+ * 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 MixedRouteHeuristicGasModelFactory
+ */
+export declare class MixedRouteHeuristicGasModelFactory extends IOnChainGasModelFactory {
+    constructor();
+    buildGasModel({ chainId, gasPriceWei, v3poolProvider: V3poolProvider, quoteToken, v2poolProvider: V2poolProvider, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<MixedRouteWithValidQuote>>;
+    private estimateGas;
+}

package/build/module/routers/alpha-router/gas-models/mixedRoute/mixed-route-heuristic-gas-model.js

@@ -0,0 +1,168 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { partitionMixedRouteByProtocol } from '@uniswap/router-sdk';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool } from '@uniswap/v3-sdk';
+import JSBI from 'jsbi';
+import _ from 'lodash';
+import { WRAPPED_NATIVE_CURRENCY } from '../../../..';
+import { log } from '../../../../util';
+import { CurrencyAmount } from '../../../../util/amounts';
+import { getHighestLiquidityV3NativePool, getHighestLiquidityV3USDPool, getV2NativePool, } from '../../../../util/gas-factory-helpers';
+import { IOnChainGasModelFactory, } from '../gas-model';
+import { BASE_SWAP_COST as BASE_SWAP_COST_V2, COST_PER_EXTRA_HOP as COST_PER_EXTRA_HOP_V2, } from '../v2/v2-heuristic-gas-model';
+import { BASE_SWAP_COST, COST_PER_HOP, COST_PER_INIT_TICK, COST_PER_UNINIT_TICK, } from '../v3/gas-costs';
+/**
+ * Computes a gas estimate for a mixed route 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 MixedRouteQuoterV1
+ * 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 MixedRouteHeuristicGasModelFactory
+ */
+export class MixedRouteHeuristicGasModelFactory extends IOnChainGasModelFactory {
+    constructor() {
+        super();
+    }
+    async buildGasModel({ chainId, gasPriceWei, v3poolProvider: V3poolProvider, quoteToken, v2poolProvider: V2poolProvider, }) {
+        const usdPool = await getHighestLiquidityV3USDPool(chainId, V3poolProvider);
+        // 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,
+            };
+        }
+        // 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 nativeV3Pool = await getHighestLiquidityV3NativePool(quoteToken, V3poolProvider);
+        let nativeV2Pool;
+        if (V2poolProvider) {
+            /// MixedRoutes
+            nativeV2Pool = await getV2NativePool(quoteToken, V2poolProvider);
+        }
+        const usdToken = usdPool.token0.address == nativeCurrency.address
+            ? usdPool.token1
+            : usdPool.token0;
+        const estimateGasCost = (routeWithValidQuote) => {
+            const { totalGasCostNativeCurrency, baseGasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId);
+            if (!nativeV3Pool && !nativeV2Pool) {
+                log.info(`Unable to find ${nativeCurrency.symbol} pool with the quote token, ${quoteToken.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),
+                };
+            }
+            /// we will use nativeV2Pool for fallback if nativeV3 does not exist or has 0 liquidity
+            /// can use ! here because we return above if v3Pool and v2Pool are null
+            const nativePool = (!nativeV3Pool || JSBI.equal(nativeV3Pool.liquidity, JSBI.BigInt(0))) &&
+                nativeV2Pool
+                ? nativeV2Pool
+                : nativeV3Pool;
+            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;
+            let gasCostInTermsOfQuoteToken;
+            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;
+            }
+            // 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;
+            }
+            return {
+                gasEstimate: baseGasUse,
+                gasCostInToken: gasCostInTermsOfQuoteToken,
+                gasCostInUSD: gasCostInTermsOfUSD,
+            };
+        };
+        return {
+            estimateGasCost: estimateGasCost.bind(this),
+        };
+    }
+    estimateGas(routeWithValidQuote, gasPriceWei, chainId) {
+        const totalInitializedTicksCrossed = BigNumber.from(Math.max(1, _.sum(routeWithValidQuote.initializedTicksCrossedList)));
+        /**
+         * Since we must make a separate call to multicall for each v3 and v2 section, we will have to
+         * add the BASE_SWAP_COST to each section.
+         */
+        let baseGasUse = BigNumber.from(0);
+        const route = routeWithValidQuote.route;
+        const res = partitionMixedRouteByProtocol(route);
+        res.map((section) => {
+            if (section.every((pool) => pool instanceof Pool)) {
+                baseGasUse = baseGasUse.add(BASE_SWAP_COST(chainId));
+                baseGasUse = baseGasUse.add(COST_PER_HOP(chainId).mul(section.length));
+            }
+            else if (section.every((pool) => pool instanceof Pair)) {
+                baseGasUse = baseGasUse.add(BASE_SWAP_COST_V2);
+                baseGasUse = baseGasUse.add(
+                /// same behavior in v2 heuristic gas model factory
+                COST_PER_EXTRA_HOP_V2.mul(section.length - 1));
+            }
+        });
+        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
+        baseGasUse = baseGasUse.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,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { V2RouteWithValidQuote } from '../../entities/route-with-valid-quote';
+import { BuildV2GasModelFactoryType, IGasModel, IV2GasModelFactory } from '../gas-model';
+export declare const BASE_SWAP_COST: BigNumber;
+export declare const COST_PER_EXTRA_HOP: BigNumber;
+/**
+ * Computes a gas estimate for a V2 swap using heuristics.
+ * Considers number of hops in the route and the typical base cost for a swap.
+ *
+ * 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.
+ *
+ * Note, certain tokens e.g. rebasing/fee-on-transfer, may incur higher gas costs than
+ * what we estimate here. This is because they run extra logic on token transfer.
+ *
+ * @export
+ * @class V2HeuristicGasModelFactory
+ */
+export declare class V2HeuristicGasModelFactory extends IV2GasModelFactory {
+    constructor();
+    buildGasModel({ chainId, gasPriceWei, poolProvider, token, }: BuildV2GasModelFactoryType): Promise<IGasModel<V2RouteWithValidQuote>>;
+    private estimateGas;
+    private getEthPool;
+    private getHighestLiquidityUSDPool;
+}

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

@@ -0,0 +1,160 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import _ from 'lodash';
+import { log, WRAPPED_NATIVE_CURRENCY } from '../../../../util';
+import { CurrencyAmount } from '../../../../util/amounts';
+import { IV2GasModelFactory, usdGasTokensByChain, } from '../gas-model';
+// Constant cost for doing any swap regardless of pools.
+export const BASE_SWAP_COST = BigNumber.from(135000); // 115000, bumped up by 20_000 @eric 7/8/2022
+// Constant per extra hop in the route.
+export const COST_PER_EXTRA_HOP = BigNumber.from(50000); // 20000, bumped up by 30_000 @eric 7/8/2022
+/**
+ * Computes a gas estimate for a V2 swap using heuristics.
+ * Considers number of hops in the route and the typical base cost for a swap.
+ *
+ * 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.
+ *
+ * Note, certain tokens e.g. rebasing/fee-on-transfer, may incur higher gas costs than
+ * what we estimate here. This is because they run extra logic on token transfer.
+ *
+ * @export
+ * @class V2HeuristicGasModelFactory
+ */
+export class V2HeuristicGasModelFactory extends IV2GasModelFactory {
+    constructor() {
+        super();
+    }
+    async buildGasModel({ chainId, gasPriceWei, poolProvider, token, }) {
+        if (token.equals(WRAPPED_NATIVE_CURRENCY[chainId])) {
+            const usdPool = await this.getHighestLiquidityUSDPool(chainId, poolProvider);
+            return {
+                estimateGasCost: (routeWithValidQuote) => {
+                    const { gasCostInEth, gasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId);
+                    const ethToken0 = usdPool.token0.address == WRAPPED_NATIVE_CURRENCY[chainId].address;
+                    const ethTokenPrice = ethToken0
+                        ? usdPool.token0Price
+                        : usdPool.token1Price;
+                    const gasCostInTermsOfUSD = ethTokenPrice.quote(gasCostInEth);
+                    return {
+                        gasEstimate: gasUse,
+                        gasCostInToken: gasCostInEth,
+                        gasCostInUSD: gasCostInTermsOfUSD,
+                    };
+                },
+            };
+        }
+        // If the quote token is not WETH, we convert the gas cost to be in terms of the quote token.
+        // We do this by getting the highest liquidity <token>/ETH pool.
+        const ethPool = await this.getEthPool(chainId, token, poolProvider);
+        if (!ethPool) {
+            log.info('Unable to find ETH pool with the quote token to produce gas adjusted costs. Route will not account for gas.');
+        }
+        const usdPool = await this.getHighestLiquidityUSDPool(chainId, poolProvider);
+        return {
+            estimateGasCost: (routeWithValidQuote) => {
+                const usdToken = usdPool.token0.address == WRAPPED_NATIVE_CURRENCY[chainId].address
+                    ? usdPool.token1
+                    : usdPool.token0;
+                const { gasCostInEth, gasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId);
+                if (!ethPool) {
+                    return {
+                        gasEstimate: gasUse,
+                        gasCostInToken: CurrencyAmount.fromRawAmount(token, 0),
+                        gasCostInUSD: CurrencyAmount.fromRawAmount(usdToken, 0),
+                    };
+                }
+                const ethToken0 = ethPool.token0.address == WRAPPED_NATIVE_CURRENCY[chainId].address;
+                const ethTokenPrice = ethToken0
+                    ? ethPool.token0Price
+                    : ethPool.token1Price;
+                let gasCostInTermsOfQuoteToken;
+                try {
+                    gasCostInTermsOfQuoteToken = ethTokenPrice.quote(gasCostInEth);
+                }
+                catch (err) {
+                    log.error({
+                        ethTokenPriceBase: ethTokenPrice.baseCurrency,
+                        ethTokenPriceQuote: ethTokenPrice.quoteCurrency,
+                        gasCostInEth: gasCostInEth.currency,
+                    }, 'Debug eth price token issue');
+                    throw err;
+                }
+                const ethToken0USDPool = usdPool.token0.address == WRAPPED_NATIVE_CURRENCY[chainId].address;
+                const ethTokenPriceUSDPool = ethToken0USDPool
+                    ? usdPool.token0Price
+                    : usdPool.token1Price;
+                let gasCostInTermsOfUSD;
+                try {
+                    gasCostInTermsOfUSD = ethTokenPriceUSDPool.quote(gasCostInEth);
+                }
+                catch (err) {
+                    log.error({
+                        usdT1: usdPool.token0.symbol,
+                        usdT2: usdPool.token1.symbol,
+                        gasCostInEthToken: gasCostInEth.currency.symbol,
+                    }, 'Failed to compute USD gas price');
+                    throw err;
+                }
+                return {
+                    gasEstimate: gasUse,
+                    gasCostInToken: gasCostInTermsOfQuoteToken,
+                    gasCostInUSD: gasCostInTermsOfUSD,
+                };
+            },
+        };
+    }
+    estimateGas(routeWithValidQuote, gasPriceWei, chainId) {
+        const hops = routeWithValidQuote.route.pairs.length;
+        const gasUse = BASE_SWAP_COST.add(COST_PER_EXTRA_HOP.mul(hops - 1));
+        const totalGasCostWei = gasPriceWei.mul(gasUse);
+        const weth = WRAPPED_NATIVE_CURRENCY[chainId];
+        const gasCostInEth = CurrencyAmount.fromRawAmount(weth, totalGasCostWei.toString());
+        return { gasCostInEth, gasUse };
+    }
+    async getEthPool(chainId, token, poolProvider) {
+        const weth = WRAPPED_NATIVE_CURRENCY[chainId];
+        const poolAccessor = await poolProvider.getPools([[weth, token]]);
+        const pool = poolAccessor.getPool(weth, token);
+        if (!pool || pool.reserve0.equalTo(0) || pool.reserve1.equalTo(0)) {
+            log.error({
+                weth,
+                token,
+                reserve0: pool === null || pool === void 0 ? void 0 : pool.reserve0.toExact(),
+                reserve1: pool === null || pool === void 0 ? void 0 : pool.reserve1.toExact(),
+            }, `Could not find a valid WETH pool with ${token.symbol} for computing gas costs.`);
+            return null;
+        }
+        return pool;
+    }
+    async getHighestLiquidityUSDPool(chainId, poolProvider) {
+        const usdTokens = usdGasTokensByChain[chainId];
+        if (!usdTokens) {
+            throw new Error(`Could not find a USD token for computing gas costs on ${chainId}`);
+        }
+        const usdPools = _.map(usdTokens, (usdToken) => [
+            usdToken,
+            WRAPPED_NATIVE_CURRENCY[chainId],
+        ]);
+        const poolAccessor = await poolProvider.getPools(usdPools);
+        const poolsRaw = poolAccessor.getAllPools();
+        const pools = _.filter(poolsRaw, (pool) => pool.reserve0.greaterThan(0) && pool.reserve1.greaterThan(0));
+        if (pools.length == 0) {
+            log.error({ pools }, `Could not find a USD/WETH pool for computing gas costs.`);
+            throw new Error(`Can't find USD/WETH pool for computing gas costs.`);
+        }
+        const maxPool = _.maxBy(pools, (pool) => {
+            if (pool.token0.equals(WRAPPED_NATIVE_CURRENCY[chainId])) {
+                return parseFloat(pool.reserve0.toSignificant(2));
+            }
+            else {
+                return parseFloat(pool.reserve1.toSignificant(2));
+            }
+        });
+        return maxPool;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '../../../..';
+export declare const COST_PER_UNINIT_TICK: BigNumber;
+export declare const BASE_SWAP_COST: (id: ChainId) => BigNumber;
+export declare const COST_PER_INIT_TICK: (id: ChainId) => BigNumber;
+export declare const COST_PER_HOP: (id: ChainId) => BigNumber;