@kumbaya_xyz/smart-order-router 4.22.38

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 '@uniswap/sdk-core';
+import { V3Route, V4Route } 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 | V4Route) => 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,189 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId } from '@uniswap/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.OPTIMISM_SEPOLIA:
+        case ChainId.BNB:
+        case ChainId.AVALANCHE:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+        case ChainId.ZORA:
+        case ChainId.ZORA_SEPOLIA:
+        case ChainId.ROOTSTOCK:
+        case ChainId.BLAST:
+        case ChainId.ZKSYNC:
+        case ChainId.WORLDCHAIN:
+        case ChainId.UNICHAIN_SEPOLIA:
+        case ChainId.UNICHAIN:
+        case ChainId.BASE_SEPOLIA:
+        case ChainId.MONAD_TESTNET: // TODO: double check on monad gas
+        case ChainId.MONAD: // TODO: double check on monad gas
+        case ChainId.SONEIUM:
+            return BigNumber.from(2000);
+        case ChainId.MEGAETH_TESTNET:
+            // Measured: USDC/USDT swap with 0 ticks = 87,610 gas
+            return BigNumber.from(80000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_GOERLI:
+        case ChainId.ARBITRUM_SEPOLIA:
+            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:
+        case ChainId.XLAYER:
+            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.OPTIMISM_SEPOLIA:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+        case ChainId.ZORA:
+        case ChainId.ZORA_SEPOLIA:
+        case ChainId.ROOTSTOCK:
+        case ChainId.BLAST:
+        case ChainId.ZKSYNC:
+        case ChainId.WORLDCHAIN:
+        case ChainId.UNICHAIN_SEPOLIA:
+        case ChainId.UNICHAIN:
+        case ChainId.BASE_SEPOLIA:
+        case ChainId.MONAD_TESTNET: // TODO: double check on monad gas
+        case ChainId.MONAD: // TODO: double check on monad gas
+        case ChainId.SONEIUM:
+            return BigNumber.from(31000);
+        case ChainId.MEGAETH_TESTNET:
+            // Measured: difference between 0-tick and 1-tick swaps ~300k-400k
+            return BigNumber.from(350000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_GOERLI:
+        case ChainId.ARBITRUM_SEPOLIA:
+            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:
+        case ChainId.XLAYER:
+            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.OPTIMISM_SEPOLIA:
+        case ChainId.AVALANCHE:
+        case ChainId.BASE:
+        case ChainId.BASE_GOERLI:
+        case ChainId.ZORA:
+        case ChainId.ZORA_SEPOLIA:
+        case ChainId.ROOTSTOCK:
+        case ChainId.BLAST:
+        case ChainId.ZKSYNC:
+        case ChainId.WORLDCHAIN:
+        case ChainId.UNICHAIN_SEPOLIA:
+        case ChainId.UNICHAIN:
+        case ChainId.BASE_SEPOLIA:
+        case ChainId.MONAD_TESTNET: // TODO: double check on monad gas
+        case ChainId.MONAD: // TODO: double check on monad gas
+        case ChainId.SONEIUM:
+            return BigNumber.from(80000);
+        case ChainId.MEGAETH_TESTNET:
+            // Measured: multi-hop overhead based on pool gas estimates
+            return BigNumber.from(100000);
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_GOERLI:
+        case ChainId.ARBITRUM_SEPOLIA:
+            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:
+        case ChainId.XLAYER:
+            return BigNumber.from(80000);
+    }
+};
+export const SINGLE_HOP_OVERHEAD = (_id) => {
+    return BigNumber.from(15000);
+};
+export const TOKEN_OVERHEAD = (id, route) => {
+    const currencies = route.protocol === Protocol.V4 ? route.currencyPath : 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 (currencies.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 (currencies.some((t) => 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,{"version":3,"file":"gas-costs.js","sourceRoot":"","sources":["../../../../../src/routers/alpha-router/gas-models/gas-costs.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,107 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId, CurrencyAmount as CurrencyAmountRaw, Token } from '@uniswap/sdk-core';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool } from '@uniswap/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, V4RouteWithValidQuote } from '../entities/route-with-valid-quote';
+export declare const usdGasTokensByChain: {
+    [chainId in ChainId]?: Token[];
+};
+export type L1ToL2GasCosts = {
+    gasUsedL1: BigNumber;
+    gasUsedL1OnL2: BigNumber;
+    gasCostL1USD: CurrencyAmount;
+    gasCostL1QuoteToken: CurrencyAmount;
+};
+export type GasModelProviderConfig = ProviderConfig & {
+    additionalGasOverhead?: BigNumber;
+    gasToken?: Token;
+};
+export type BuildOnChainGasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    pools: LiquidityCalculationPools;
+    amountToken: Token;
+    quoteToken: Token;
+    v2poolProvider: IV2PoolProvider;
+    l2GasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    providerConfig?: GasModelProviderConfig;
+};
+export type BuildV2GasModelFactoryType = {
+    chainId: ChainId;
+    gasPriceWei: BigNumber;
+    poolProvider: IV2PoolProvider;
+    token: Token;
+    l2GasDataProvider?: IL2GasDataProvider<ArbitrumGasData>;
+    providerConfig?: GasModelProviderConfig;
+};
+export type LiquidityCalculationPools = {
+    usdPool: Pool;
+    nativeAndQuoteTokenV3Pool: Pool | null;
+    nativeAndAmountTokenV3Pool: Pool | null;
+    nativeAndSpecifiedGasTokenV3Pool: Pool | null;
+};
+export type GasModelType = {
+    v2GasModel?: IGasModel<V2RouteWithValidQuote>;
+    v3GasModel: IGasModel<V3RouteWithValidQuote>;
+    v4GasModel: IGasModel<V4RouteWithValidQuote>;
+    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 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,111 @@
+import { ChainId, } from '@uniswap/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_UNICHAIN, DAI_ZKSYNC, USDB_BLAST, USDC_ARBITRUM, USDC_ARBITRUM_GOERLI, USDC_ARBITRUM_SEPOLIA, USDC_AVAX, USDC_BASE, USDC_BASE_SEPOLIA, USDC_BNB, USDC_BRIDGED_AVAX, USDC_CELO, USDC_ETHEREUM_GNOSIS, USDC_GOERLI, USDC_MAINNET, USDC_MONAD, 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_SONEIUM, USDC_UNICHAIN, USDC_UNICHAIN_SEPOLIA, USDC_WORLDCHAIN, USDC_WORMHOLE_CELO, USDC_ZKSYNC, USDC_ZORA, USDCE_ZKSYNC, USDT_ARBITRUM, USDT_BNB, USDT_GOERLI, USDT_MAINNET, USDT_MONAD_TESTNET, USDT_OPTIMISM, USDT_OPTIMISM_GOERLI, USDT_OPTIMISM_SEPOLIA, WBTC_GOERLI, } 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.MAINNET]: [DAI_MAINNET, USDC_MAINNET, USDT_MAINNET],
+    [ChainId.ARBITRUM_ONE]: [
+        DAI_ARBITRUM,
+        USDC_ARBITRUM,
+        USDC_NATIVE_ARBITRUM,
+        USDT_ARBITRUM,
+    ],
+    [ChainId.OPTIMISM]: [
+        DAI_OPTIMISM,
+        USDC_OPTIMISM,
+        USDC_NATIVE_OPTIMISM,
+        USDT_OPTIMISM,
+    ],
+    [ChainId.OPTIMISM_GOERLI]: [
+        DAI_OPTIMISM_GOERLI,
+        USDC_OPTIMISM_GOERLI,
+        USDT_OPTIMISM_GOERLI,
+    ],
+    [ChainId.OPTIMISM_SEPOLIA]: [
+        DAI_OPTIMISM_SEPOLIA,
+        USDC_OPTIMISM_SEPOLIA,
+        USDT_OPTIMISM_SEPOLIA,
+    ],
+    [ChainId.ARBITRUM_GOERLI]: [USDC_ARBITRUM_GOERLI],
+    [ChainId.ARBITRUM_SEPOLIA]: [USDC_ARBITRUM_SEPOLIA],
+    [ChainId.GOERLI]: [DAI_GOERLI, USDC_GOERLI, USDT_GOERLI, WBTC_GOERLI],
+    [ChainId.SEPOLIA]: [USDC_SEPOLIA, DAI_SEPOLIA],
+    [ChainId.POLYGON]: [USDC_POLYGON, USDC_NATIVE_POLYGON],
+    [ChainId.POLYGON_MUMBAI]: [DAI_POLYGON_MUMBAI],
+    [ChainId.CELO]: [CUSD_CELO, USDC_CELO, USDC_NATIVE_CELO, USDC_WORMHOLE_CELO],
+    [ChainId.CELO_ALFAJORES]: [CUSD_CELO_ALFAJORES],
+    [ChainId.GNOSIS]: [USDC_ETHEREUM_GNOSIS],
+    [ChainId.MOONBEAM]: [USDC_MOONBEAM],
+    [ChainId.BNB]: [USDT_BNB, USDC_BNB, DAI_BNB],
+    [ChainId.AVALANCHE]: [
+        DAI_AVAX,
+        USDC_AVAX,
+        USDC_NATIVE_AVAX,
+        USDC_BRIDGED_AVAX,
+    ],
+    [ChainId.BASE]: [USDC_BASE, USDC_NATIVE_BASE],
+    [ChainId.BLAST]: [USDB_BLAST],
+    [ChainId.ZORA]: [USDC_ZORA],
+    [ChainId.ZKSYNC]: [DAI_ZKSYNC, USDCE_ZKSYNC, USDC_ZKSYNC],
+    [ChainId.WORLDCHAIN]: [USDC_WORLDCHAIN],
+    [ChainId.UNICHAIN_SEPOLIA]: [USDC_UNICHAIN_SEPOLIA],
+    [ChainId.MONAD_TESTNET]: [USDT_MONAD_TESTNET],
+    [ChainId.MONAD]: [USDC_MONAD],
+    [ChainId.BASE_SEPOLIA]: [USDC_BASE_SEPOLIA],
+    [ChainId.UNICHAIN]: [DAI_UNICHAIN, USDC_UNICHAIN],
+    [ChainId.SONEIUM]: [USDC_SONEIUM],
+};
+/**
+ * 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 '@uniswap/router-sdk';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool as V3Pool } from '@uniswap/v3-sdk';
+import { Pool as V4Pool } from '@uniswap/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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