@fanx-protocol/smart-order-router 0.0.1

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

@@ -0,0 +1,12 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId, Currency } from '@fanx-protocol/sdk-core';
+import { V3Route } from '../../router';
+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;
+export declare const SINGLE_HOP_OVERHEAD: (_id: ChainId) => BigNumber;
+export declare const TOKEN_OVERHEAD: (_id: ChainId, _route: V3Route) => BigNumber;
+export declare const NATIVE_WRAP_OVERHEAD: (id: ChainId) => BigNumber;
+export declare const NATIVE_UNWRAP_OVERHEAD: (id: ChainId) => BigNumber;
+export declare const NATIVE_OVERHEAD: (chainId: ChainId, amount: Currency, quote: Currency) => BigNumber;

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

@@ -0,0 +1,79 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '@fanx-protocol/sdk-core';
+// 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.SPICY:
+        case ChainId.CHILIZ:
+            return BigNumber.from(2000);
+        default:
+            return BigNumber.from(2000);
+    }
+};
+export const COST_PER_INIT_TICK = (id) => {
+    switch (id) {
+        case ChainId.SPICY:
+        case ChainId.CHILIZ:
+            return BigNumber.from(31000);
+        default:
+            return BigNumber.from(31000);
+    }
+};
+export const COST_PER_HOP = (id) => {
+    switch (id) {
+        case ChainId.SPICY:
+        case ChainId.CHILIZ:
+            return BigNumber.from(80000);
+        default:
+            return BigNumber.from(80000);
+    }
+};
+export const SINGLE_HOP_OVERHEAD = (_id) => {
+    return BigNumber.from(15000);
+};
+export const TOKEN_OVERHEAD = (_id, _route /* | V4Route */) => {
+    // const currencies: Currency[] = route.tokenPath; // route.protocol === Protocol.V4 ? route.currencyPath : route.tokenPath;
+    let overhead = BigNumber.from(0);
+    // AAVE and LIDO token overhead logic removed - only Chiliz and Spicy are supported
+    // if (id == ChainId.MAINNET) {
+    //   // AAVE's transfer contains expensive governance snapshotting logic. We estimate
+    //   // it at around 150k.
+    //   if (currencies.some((t: Currency) => 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 (currencies.some((t: Currency) => t.equals(LIDO_MAINNET))) {
+    //     overhead = overhead.add(150000);
+    //   }
+    // }
+    return overhead;
+};
+// TODO: change per chain
+export const NATIVE_WRAP_OVERHEAD = (id) => {
+    switch (id) {
+        default:
+            return BigNumber.from(27938);
+    }
+};
+export const NATIVE_UNWRAP_OVERHEAD = (id) => {
+    switch (id) {
+        default:
+            return BigNumber.from(36000);
+    }
+};
+export const NATIVE_OVERHEAD = (chainId, amount, quote) => {
+    if (amount.isNative) {
+        // need to wrap eth in
+        return NATIVE_WRAP_OVERHEAD(chainId);
+    }
+    if (quote.isNative) {
+        // need to unwrap eth out
+        return NATIVE_UNWRAP_OVERHEAD(chainId);
+    }
+    return BigNumber.from(0);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,106 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId, CurrencyAmount as CurrencyAmountRaw, Token } from '@fanx-protocol/sdk-core';
+import { Pair } from '@fanx-protocol/v2-sdk';
+import { Pool } from '@fanx-protocol/v3-sdk';
+import { ProviderConfig } from '../../../providers/provider';
+import { IV2PoolProvider } from '../../../providers/v2/pool-provider';
+import { ArbitrumGasData, IL2GasDataProvider } from '../../../providers/v3/gas-data-provider';
+import { CurrencyAmount } from '../../../util/amounts';
+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;
+    gasUsedL1OnL2: BigNumber;
+    gasCostL1USD: CurrencyAmount;
+    gasCostL1QuoteToken: CurrencyAmount;
+};
+export declare type GasModelProviderConfig = ProviderConfig & {
+    additionalGasOverhead?: BigNumber;
+    gasToken?: Token;
+};
+export declare type BuildOnChainGasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    pools: LiquidityCalculationPools;
+    amountToken: Token;
+    quoteToken: Token;
+    v2poolProvider: IV2PoolProvider;
+    l2GasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    providerConfig?: GasModelProviderConfig;
+};
+export declare type BuildV2GasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    poolProvider: IV2PoolProvider;
+    token: Token;
+    l2GasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    providerConfig?: GasModelProviderConfig;
+};
+export declare type LiquidityCalculationPools = {
+    usdPool: Pool;
+    nativeAndQuoteTokenV3Pool: Pool | null;
+    nativeAndAmountTokenV3Pool: Pool | null;
+    nativeAndSpecifiedGasTokenV3Pool: Pool | null;
+};
+export declare type GasModelType = {
+    v2GasModel?: IGasModel<V2RouteWithValidQuote>;
+    v3GasModel: IGasModel<V3RouteWithValidQuote>;
+    mixedRouteGasModel: IGasModel<MixedRouteWithValidQuote>;
+};
+/**
+ * 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;
+        gasCostInGasToken?: 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, providerConfig, }: 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<TRouteWithValidQuote extends RouteWithValidQuote> {
+    abstract buildGasModel({ chainId, gasPriceWei, pools, amountToken, quoteToken, v2poolProvider, l2GasDataProvider, providerConfig, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<TRouteWithValidQuote>>;
+    protected totalInitializedTicksCrossed(initializedTicksCrossedList: number[]): number;
+}
+export declare const getQuoteThroughNativePool: (chainId: ChainId, nativeTokenAmount: CurrencyAmountRaw<Token>, nativeTokenPool: Pool | Pair) => CurrencyAmount;

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

@@ -0,0 +1,102 @@
+import { ChainId, } from '@fanx-protocol/sdk-core';
+import { 
+// CUSD_CELO,
+// CUSD_CELO_ALFAJORES,
+// DAI_ARBITRUM,
+// DAI_AVAX,
+// DAI_BNB,
+// DAI_GOERLI,
+// DAI_MAINNET,
+// DAI_OPTIMISM,
+// DAI_OPTIMISM_GOERLI,
+// DAI_OPTIMISM_SEPOLIA,
+// DAI_POLYGON_MUMBAI,
+// DAI_SEPOLIA,
+// DAI_ZKSYNC,
+// USDB_BLAST,
+// USDCE_ZKSYNC,
+// USDC_ARBITRUM,
+// USDC_ARBITRUM_GOERLI,
+// USDC_ARBITRUM_SEPOLIA,
+// USDC_AVAX,
+// USDC_BASE,
+// USDC_BNB,
+// USDC_BRIDGED_AVAX,
+// USDC_CELO,
+USDC_CHILIZ, 
+// USDC_ETHEREUM_GNOSIS,
+// USDC_GOERLI,
+// USDC_MAINNET,
+// USDC_MOONBEAM,
+// USDC_NATIVE_ARBITRUM,
+// USDC_NATIVE_AVAX,
+// USDC_NATIVE_BASE,
+// USDC_NATIVE_CELO,
+// USDC_NATIVE_OPTIMISM,
+// USDC_NATIVE_POLYGON,
+// USDC_OPTIMISM,
+// USDC_OPTIMISM_GOERLI,
+// USDC_OPTIMISM_SEPOLIA,
+// USDC_POLYGON,
+// USDC_SEPOLIA,
+USDC_SPICY, } from '../../../providers/token-provider';
+import { WRAPPED_NATIVE_CURRENCY } from '../../../util';
+// When adding new usd gas tokens, ensure the tokens are ordered
+// from tokens with highest decimals to lowest decimals. For example,
+// DAI_AVAX has 18 decimals and comes before USDC_AVAX which has 6 decimals.
+export const usdGasTokensByChain = {
+    [ChainId.CHILIZ]: [USDC_CHILIZ],
+    [ChainId.SPICY]: [USDC_SPICY],
+};
+/**
+ * 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 {
+    totalInitializedTicksCrossed(initializedTicksCrossedList) {
+        let ticksCrossed = 0;
+        for (let i = 0; i < initializedTicksCrossedList.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            if (initializedTicksCrossedList[i] > 0) {
+                // Quoter returns Array<number of calls to crossTick + 1>, so we need to subtract 1 here.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                ticksCrossed += initializedTicksCrossedList[i] - 1;
+            }
+        }
+        return ticksCrossed;
+    }
+}
+// Determines if native currency is token0
+// Gets the native price of the pool, dependent on 0 or 1
+// quotes across the pool
+export const getQuoteThroughNativePool = (chainId, nativeTokenAmount, nativeTokenPool) => {
+    const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+    const isToken0 = nativeTokenPool.token0.equals(nativeCurrency);
+    // returns mid price in terms of the native currency (the ratio of token/nativeToken)
+    const nativeTokenPrice = isToken0
+        ? nativeTokenPool.token0Price
+        : nativeTokenPool.token1Price;
+    // return gas cost in terms of the non native currency
+    return nativeTokenPrice.quote(nativeTokenAmount);
+};
+//# 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,24 @@
+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<MixedRouteWithValidQuote> {
+    buildGasModel({ chainId, gasPriceWei, pools, quoteToken, v2poolProvider: V2poolProvider, providerConfig, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<MixedRouteWithValidQuote>>;
+    private estimateGas;
+}

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

@@ -0,0 +1,154 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { partitionMixedRouteByProtocol } from '@fanx-protocol/router-sdk';
+import { Pair } from '@fanx-protocol/v2-sdk';
+import { Pool as V3Pool } from '@fanx-protocol/v3-sdk';
+// import { Pool as V4Pool } from '@fanx-protocol/v4-sdk';
+import JSBI from 'jsbi';
+import { WRAPPED_NATIVE_CURRENCY } from '../../../..';
+import { log } from '../../../../util';
+import { CurrencyAmount } from '../../../../util/amounts';
+import { getV2NativePool } from '../../../../util/gas-factory-helpers';
+import { BASE_SWAP_COST, COST_PER_HOP, COST_PER_INIT_TICK, COST_PER_UNINIT_TICK, } from '../gas-costs';
+import { getQuoteThroughNativePool, 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';
+/**
+ * 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 {
+    async buildGasModel({ chainId, gasPriceWei, pools, quoteToken, v2poolProvider: V2poolProvider, providerConfig, }) {
+        const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+        const usdPool = pools.usdPool;
+        const usdToken = usdPool.token0.equals(nativeCurrency)
+            ? usdPool.token1
+            : usdPool.token0;
+        let nativeV2Pool;
+        // Avoid fetching for a (WETH,WETH) pool here, we handle the quoteToken = wrapped native case in estimateGasCost
+        if (!quoteToken.equals(nativeCurrency) && V2poolProvider) {
+            /// MixedRoutes
+            nativeV2Pool = await getV2NativePool(quoteToken, V2poolProvider, providerConfig);
+        }
+        const estimateGasCost = (routeWithValidQuote) => {
+            var _a;
+            const { totalGasCostNativeCurrency, baseGasUse } = this.estimateGas(routeWithValidQuote, gasPriceWei, chainId, providerConfig);
+            /** ------ MARK: USD Logic -------- */
+            const gasCostInTermsOfUSD = getQuoteThroughNativePool(chainId, totalGasCostNativeCurrency, usdPool);
+            /** ------ MARK: Conditional logic run if gasToken is specified  -------- */
+            const nativeAndSpecifiedGasTokenPool = pools.nativeAndSpecifiedGasTokenV3Pool;
+            let gasCostInTermsOfGasToken = undefined;
+            if (nativeAndSpecifiedGasTokenPool) {
+                gasCostInTermsOfGasToken = getQuoteThroughNativePool(chainId, totalGasCostNativeCurrency, nativeAndSpecifiedGasTokenPool);
+            }
+            // if the gasToken is the native currency, we can just use the totalGasCostNativeCurrency
+            else if ((_a = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.gasToken) === null || _a === void 0 ? void 0 : _a.equals(nativeCurrency)) {
+                gasCostInTermsOfGasToken = totalGasCostNativeCurrency;
+            }
+            /** ------ MARK: return early if quoteToken is wrapped native currency ------- */
+            if (quoteToken.equals(nativeCurrency)) {
+                return {
+                    gasEstimate: baseGasUse,
+                    gasCostInToken: totalGasCostNativeCurrency,
+                    gasCostInUSD: gasCostInTermsOfUSD,
+                    gasCostInGasToken: gasCostInTermsOfGasToken,
+                };
+            }
+            /** ------ MARK: Main gas logic in terms of quote token -------- */
+            // 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 = pools.nativeAndQuoteTokenV3Pool;
+            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 gasCostInTermsOfQuoteToken = getQuoteThroughNativePool(chainId, totalGasCostNativeCurrency, nativePool);
+            return {
+                gasEstimate: baseGasUse,
+                gasCostInToken: gasCostInTermsOfQuoteToken,
+                gasCostInUSD: gasCostInTermsOfUSD,
+                gasCostInGasToken: gasCostInTermsOfGasToken,
+            };
+        };
+        return {
+            estimateGasCost: estimateGasCost.bind(this),
+        };
+    }
+    estimateGas(routeWithValidQuote, gasPriceWei, chainId, providerConfig) {
+        const totalInitializedTicksCrossed = this.totalInitializedTicksCrossed(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 baseGasUseV2Only = BigNumber.from(0);
+        let baseGasUseV3Only = BigNumber.from(0);
+        let baseGasUse = BigNumber.from(0);
+        let routeContainsV4Pool = false;
+        const route = routeWithValidQuote.route;
+        const res = partitionMixedRouteByProtocol(route);
+        res.map((section) => {
+            if (section.every((pool) => pool instanceof V3Pool)) {
+                baseGasUseV3Only = baseGasUseV3Only.add(BASE_SWAP_COST(chainId));
+                baseGasUseV3Only = baseGasUseV3Only.add(COST_PER_HOP(chainId).mul(section.length));
+                baseGasUse = baseGasUse.add(baseGasUseV3Only);
+            }
+            else if (section.every((pool) => pool instanceof Pair)) {
+                baseGasUseV2Only = baseGasUseV2Only.add(BASE_SWAP_COST_V2);
+                baseGasUseV2Only = baseGasUseV2Only.add(
+                /// same behavior in v2 heuristic gas model factory
+                COST_PER_EXTRA_HOP_V2.mul(section.length - 1));
+                baseGasUse = baseGasUse.add(baseGasUseV2Only);
+            }
+            // } else if (section.every((pool) => pool instanceof V4Pool)) {
+            //   routeContainsV4Pool = true;
+            // }
+        });
+        const tickGasUse = COST_PER_INIT_TICK(chainId).mul(totalInitializedTicksCrossed);
+        const uninitializedTickGasUse = COST_PER_UNINIT_TICK.mul(0);
+        if (routeContainsV4Pool) {
+            // If the route contains a V4 pool, we know we are hitting mixed quoter V2, not mixed quoter V1,
+            // Hence we already know the v3 and v4 hops part of the quoter gas estimate.
+            // We only need to add the base gas use for the v2 part of the route,
+            // because mixed quoter doesn't have a way to estimate gas for v2 pools swaps.
+            baseGasUse = baseGasUseV2Only.add(routeWithValidQuote.quoterGasEstimate);
+        }
+        else {
+            // base estimate gas used based on chainId estimates for hops and ticks gas useage
+            baseGasUse = baseGasUse.add(tickGasUse).add(uninitializedTickGasUse);
+        }
+        if (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.additionalGasOverhead) {
+            baseGasUse = baseGasUse.add(providerConfig.additionalGasOverhead);
+        }
+        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/tick-based-heuristic-gas-model.d.ts

@@ -0,0 +1,15 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { BaseProvider } from '@ethersproject/providers';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { V3RouteWithValidQuote } from '../entities';
+import { BuildOnChainGasModelFactoryType, GasModelProviderConfig, IGasModel, IOnChainGasModelFactory } from './gas-model';
+export declare abstract class TickBasedHeuristicGasModelFactory<TRouteWithValidQuote extends V3RouteWithValidQuote> extends IOnChainGasModelFactory<TRouteWithValidQuote> {
+    protected provider: BaseProvider;
+    protected constructor(provider: BaseProvider);
+    protected buildGasModelInternal({ chainId, gasPriceWei, pools, amountToken, quoteToken, l2GasDataProvider, providerConfig, }: BuildOnChainGasModelFactoryType): Promise<IGasModel<TRouteWithValidQuote>>;
+    protected estimateGas(routeWithValidQuote: TRouteWithValidQuote, gasPriceWei: BigNumber, chainId: ChainId, providerConfig?: GasModelProviderConfig): {
+        totalGasCostNativeCurrency: import("@fanx-protocol/sdk-core").CurrencyAmount<import("@fanx-protocol/sdk-core").Token>;
+        totalInitializedTicksCrossed: number;
+        baseGasUse: BigNumber;
+    };
+}