@ring-protocol/smart-order-router 0.5.0

package/build/module/util/gas-factory-helpers.js

@@ -0,0 +1,575 @@
+import { estimateL1Gas, estimateL1GasCost } from '@eth-optimism/sdk';
+import { BigNumber } from '@ethersproject/bignumber';
+import { Protocol } from '@ring-protocol/router-sdk';
+import { ChainId, Percent, Token, TradeType } from '@ring-protocol/sdk-core';
+import { UniversalRouterVersion } from '@ring-protocol/universal-router-sdk';
+import { Pair as RingFewPair } from '@ring-protocol/few-v2-sdk';
+import { getFewTokenFromOriginalToken } from '@ring-protocol/few-v2-sdk';
+import JSBI from 'jsbi';
+import _ from 'lodash';
+import { getQuoteThroughNativePool, getRingQuoteThroughNativePool, metric, MetricLoggerUnit, MixedRouteWithValidQuote, ringUsdGasTokensByChain, SwapType, usdGasTokensByChain, V2RouteWithValidQuote, V3RouteWithValidQuote, V4RouteWithValidQuote, } from '../routers';
+import { CurrencyAmount, FEW_WRAPPED_NATIVE_CURRENCY, getApplicableV3FeeAmounts, log, WRAPPED_NATIVE_CURRENCY, } from '../util';
+import { isFewToken } from './fewAddress';
+import { opStackChains } from './l2FeeChains';
+import { buildSwapMethodParameters, buildTrade } from './methodParameters';
+export async function getV2NativePool(token, poolProvider, providerConfig) {
+    const chainId = token.chainId;
+    const weth = WRAPPED_NATIVE_CURRENCY[chainId];
+    const poolAccessor = await poolProvider.getPools([[weth, token]], providerConfig);
+    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 V2 pool with ${token.symbol} for computing gas costs.`);
+        return null;
+    }
+    return pool;
+}
+export async function getRingFewV2NativePool(token, poolProvider, providerConfig) {
+    const chainId = token.chainId;
+    const weth = FEW_WRAPPED_NATIVE_CURRENCY[chainId];
+    const poolAccessor = await poolProvider.getPools([[weth, token]], providerConfig);
+    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 V2 pool with ${token.symbol} for computing gas costs.`);
+        return null;
+    }
+    return pool;
+}
+export async function getHighestLiquidityV3NativePool(token, poolProvider, providerConfig) {
+    const nativeCurrency = WRAPPED_NATIVE_CURRENCY[token.chainId];
+    const feeAmounts = getApplicableV3FeeAmounts(token.chainId);
+    const nativePools = _(feeAmounts)
+        .map((feeAmount) => {
+        return [nativeCurrency, token, feeAmount];
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(nativePools, providerConfig);
+    const pools = _(feeAmounts)
+        .map((feeAmount) => {
+        return poolAccessor.getPool(nativeCurrency, token, feeAmount);
+    })
+        .compact()
+        .value();
+    if (pools.length == 0) {
+        log.error({ pools }, `Could not find a ${nativeCurrency.symbol} pool with ${token.symbol} for computing gas costs.`);
+        return null;
+    }
+    const maxPool = pools.reduce((prev, current) => {
+        return JSBI.greaterThan(prev.liquidity, current.liquidity) ? prev : current;
+    });
+    return maxPool;
+}
+export async function getHighestLiquidityV3NativeFewTokenPool(token, poolProvider, providerConfig) {
+    const nativeCurrency = FEW_WRAPPED_NATIVE_CURRENCY[token.chainId];
+    const feeAmounts = getApplicableV3FeeAmounts(token.chainId);
+    const nativePools = _(feeAmounts)
+        .map((feeAmount) => {
+        return [nativeCurrency, token, feeAmount];
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(nativePools, providerConfig);
+    const pools = _(feeAmounts)
+        .map((feeAmount) => {
+        return poolAccessor.getPool(nativeCurrency, token, feeAmount);
+    })
+        .compact()
+        .value();
+    if (pools.length == 0) {
+        log.error({ pools }, `Could not find a ${nativeCurrency.symbol} pool with ${token.symbol} for computing gas costs.`);
+        return null;
+    }
+    const maxPool = pools.reduce((prev, current) => {
+        return JSBI.greaterThan(prev.liquidity, current.liquidity) ? prev : current;
+    });
+    return maxPool;
+}
+export async function getHighestLiquidityV3USDPool(chainId, poolProvider, providerConfig) {
+    const usdTokens = usdGasTokensByChain[chainId];
+    const wrappedCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+    if (!usdTokens) {
+        throw new Error(`Could not find a USD token for computing gas costs on ${chainId}`);
+    }
+    const feeAmounts = getApplicableV3FeeAmounts(chainId);
+    const usdPools = _(feeAmounts)
+        .flatMap((feeAmount) => {
+        return _.map(usdTokens, (usdToken) => [
+            wrappedCurrency,
+            usdToken,
+            feeAmount,
+        ]);
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(usdPools, providerConfig);
+    const pools = _(feeAmounts)
+        .flatMap((feeAmount) => {
+        const pools = [];
+        for (const usdToken of usdTokens) {
+            const pool = poolAccessor.getPool(wrappedCurrency, usdToken, feeAmount);
+            if (pool) {
+                pools.push(pool);
+            }
+        }
+        return pools;
+    })
+        .compact()
+        .value();
+    if (pools.length == 0) {
+        const message = `Could not find a USD/${wrappedCurrency.symbol} pool for computing gas costs.`;
+        log.error({ pools }, message);
+        // throw new Error(message);
+        return null;
+    }
+    const maxPool = pools.reduce((prev, current) => {
+        return JSBI.greaterThan(prev.liquidity, current.liquidity) ? prev : current;
+    });
+    return maxPool;
+}
+export async function getHighestLiquidityV3FewTokenUSDPool(chainId, poolProvider, providerConfig) {
+    // const only_support_v2_network: ChainId[] = [
+    //   ChainId.BLAST,
+    // ]
+    // const usdTokens = only_support_v2_network.includes(chainId)
+    //   ? onlySupportV2NetworkUsdGasTokensByChain[chainId]
+    // : ringUsdGasTokensByChain[chainId];
+    // const wrappedCurrency = only_support_v2_network.includes(chainId)
+    //   ? WRAPPED_NATIVE_CURRENCY[chainId]!
+    // : FEW_WRAPPED_NATIVE_CURRENCY[chainId]!;
+    const usdTokens = ringUsdGasTokensByChain[chainId];
+    const wrappedCurrency = FEW_WRAPPED_NATIVE_CURRENCY[chainId];
+    if (!usdTokens) {
+        throw new Error(`Could not find a USD token for computing gas costs on ${chainId}`);
+    }
+    const feeAmounts = getApplicableV3FeeAmounts(chainId);
+    const usdPools = _(feeAmounts)
+        .flatMap((feeAmount) => {
+        return _.map(usdTokens, (usdToken) => [
+            wrappedCurrency,
+            usdToken,
+            feeAmount,
+        ]);
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(usdPools, providerConfig);
+    const pools = _(feeAmounts)
+        .flatMap((feeAmount) => {
+        const pools = [];
+        for (const usdToken of usdTokens) {
+            const pool = poolAccessor.getPool(wrappedCurrency, usdToken, feeAmount);
+            if (pool) {
+                pools.push(pool);
+            }
+        }
+        return pools;
+    })
+        .compact()
+        .value();
+    if (pools.length == 0) {
+        const message = `Could not find a USD/${wrappedCurrency.symbol} few pool for computing gas costs.`;
+        log.error({ pools }, message);
+        // throw new Error(message);
+        return null;
+    }
+    const maxPool = pools.reduce((prev, current) => {
+        return JSBI.greaterThan(prev.liquidity, current.liquidity) ? prev : current;
+    });
+    return maxPool;
+}
+export function getGasCostInNativeCurrency(nativeCurrency, gasCostInWei) {
+    // wrap fee to native currency
+    const costNativeCurrency = CurrencyAmount.fromRawAmount(nativeCurrency, gasCostInWei.toString());
+    return costNativeCurrency;
+}
+export function getArbitrumBytes(data) {
+    if (data == '')
+        return BigNumber.from(0);
+    // Calculate actual bytes (remove '0x' prefix, every 2 hex characters = 1 byte)
+    const actualBytes = (data.length - 2) / 2;
+    // Smart compression ratio estimation based on data characteristics
+    let compressionRatio = 0.5; // Default baseline compression ratio
+    // 1. Detect zero byte density (zero bytes compress very well)
+    const zeroBytes = (data.match(/00/g) || []).length;
+    const zeroDensity = zeroBytes / actualBytes;
+    // 2. Detect repeated patterns
+    const repeatedPatterns = countRepeatedPatterns(data);
+    const repetitionScore = Math.min(repeatedPatterns / actualBytes, 0.5);
+    // 3. Detect function call pattern (calldata characteristics)
+    const isFunctionCall = data.length > 10 && /^0x[a-f0-9]{8}/.test(data);
+    // 4. Calculate dynamic compression ratio
+    if (zeroDensity > 0.5) {
+        // High zero byte density: excellent compression
+        compressionRatio = 0.25 + (zeroDensity * 0.2);
+    }
+    else if (zeroDensity > 0.3) {
+        // Medium zero byte density: good compression
+        compressionRatio = 0.35 + (zeroDensity * 0.3);
+    }
+    else if (isFunctionCall) {
+        // Standard function call: typical compression
+        compressionRatio = 0.45 - (repetitionScore * 0.1);
+    }
+    else if (repetitionScore > 0.2) {
+        // High repetition pattern: better compression
+        compressionRatio = 0.4 - (repetitionScore * 0.15);
+    }
+    else {
+        // Random data: poor compression
+        compressionRatio = 0.55 + (Math.random() * 0.1 - 0.05); // Add slight randomness
+    }
+    // Ensure compression ratio is within reasonable bounds
+    compressionRatio = Math.max(0.2, Math.min(0.8, compressionRatio));
+    const estimatedCompressedSize = Math.floor(actualBytes * compressionRatio);
+    // Apply original 20% buffer (due to using Brotli 1 instead of Brotli 0)
+    return BigNumber.from(estimatedCompressedSize).mul(120).div(100);
+}
+// Helper function: detect repeated patterns
+function countRepeatedPatterns(data) {
+    const cleanData = data.replace('0x', '');
+    let patterns = 0;
+    // Detect 2-8 byte repeated patterns
+    for (let patternLength = 4; patternLength <= 16; patternLength += 2) {
+        const pattern = cleanData.substring(0, patternLength);
+        const regex = new RegExp(pattern, 'g');
+        const matches = (cleanData.match(regex) || []).length;
+        if (matches > 1) {
+            patterns += (matches - 1) * (patternLength / 2); // Convert to byte count
+        }
+    }
+    return patterns;
+}
+export function calculateArbitrumToL1FeeFromCalldata(calldata, gasData, chainId) {
+    const { perL2TxFee, perL1CalldataFee, perArbGasTotal } = gasData;
+    // calculates gas amounts based on bytes of calldata, use 0 as overhead.
+    const l1GasUsed = getL2ToL1GasUsed(calldata, chainId);
+    // multiply by the fee per calldata and add the flat l2 fee
+    const l1Fee = l1GasUsed.mul(perL1CalldataFee).add(perL2TxFee);
+    const gasUsedL1OnL2 = l1Fee.div(perArbGasTotal);
+    return [l1GasUsed, l1Fee, gasUsedL1OnL2];
+}
+export async function calculateOptimismToL1FeeFromCalldata(calldata, chainId, provider) {
+    const tx = {
+        data: calldata,
+        chainId: chainId,
+        type: 2, // sign the transaction as EIP-1559, otherwise it will fail at maxFeePerGas
+    };
+    const [l1GasUsed, l1GasCost] = await Promise.all([
+        estimateL1Gas(provider, tx),
+        estimateL1GasCost(provider, tx),
+    ]);
+    return [l1GasUsed, l1GasCost];
+}
+export function getL2ToL1GasUsed(data, chainId) {
+    switch (chainId) {
+        case ChainId.ARBITRUM_ONE:
+        case ChainId.ARBITRUM_GOERLI: {
+            // calculates bytes of compressed calldata
+            const l1ByteUsed = getArbitrumBytes(data);
+            return l1ByteUsed.mul(16);
+        }
+        default:
+            return BigNumber.from(0);
+    }
+}
+export async function calculateGasUsed(chainId, route, simulatedGasUsed, v2PoolProvider, v3PoolProvider, provider, providerConfig) {
+    const quoteToken = route.quote.currency.wrapped;
+    const gasPriceWei = route.gasPriceWei;
+    // calculate L2 to L1 security fee if relevant
+    let l2toL1FeeInWei = BigNumber.from(0);
+    // Arbitrum charges L2 gas for L1 calldata posting costs.
+    // See https://github.com/Uniswap/smart-order-router/pull/464/files#r1441376802
+    if (opStackChains.includes(chainId)) {
+        l2toL1FeeInWei = (await calculateOptimismToL1FeeFromCalldata(route.methodParameters.calldata, chainId, provider))[1];
+    }
+    // add l2 to l1 fee and wrap fee to native currency
+    const gasCostInWei = gasPriceWei.mul(simulatedGasUsed).add(l2toL1FeeInWei);
+    const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+    const costNativeCurrency = getGasCostInNativeCurrency(nativeCurrency, gasCostInWei);
+    const usdPool = await getHighestLiquidityV3USDPool(chainId, v3PoolProvider, providerConfig);
+    /** ------ MARK: USD logic  -------- */
+    const gasCostUSD = getQuoteThroughNativePool(chainId, costNativeCurrency, usdPool);
+    /** ------ MARK: Conditional logic run if gasToken is specified  -------- */
+    let gasCostInTermsOfGasToken = undefined;
+    if (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.gasToken) {
+        if (providerConfig.gasToken.equals(nativeCurrency)) {
+            gasCostInTermsOfGasToken = costNativeCurrency;
+        }
+        else {
+            const nativeAndSpecifiedGasTokenPool = await getHighestLiquidityV3NativePool(providerConfig.gasToken, v3PoolProvider, providerConfig);
+            if (nativeAndSpecifiedGasTokenPool) {
+                gasCostInTermsOfGasToken = getQuoteThroughNativePool(chainId, costNativeCurrency, nativeAndSpecifiedGasTokenPool);
+            }
+            else {
+                log.info(`Could not find a V3 pool for gas token ${providerConfig.gasToken.symbol}`);
+            }
+        }
+    }
+    /** ------ MARK: Main gas logic in terms of quote token -------- */
+    let gasCostQuoteToken = undefined;
+    // shortcut if quote token is native currency
+    if (quoteToken.equals(nativeCurrency)) {
+        gasCostQuoteToken = costNativeCurrency;
+    }
+    // get fee in terms of quote token
+    else {
+        const nativePools = await Promise.all([
+            getHighestLiquidityV3NativePool(quoteToken, v3PoolProvider, providerConfig),
+            getV2NativePool(quoteToken, v2PoolProvider, providerConfig),
+        ]);
+        const nativePool = nativePools.find((pool) => pool !== null);
+        if (!nativePool) {
+            log.info('Could not find any V2 or V3 pools to convert the cost into the quote token');
+            gasCostQuoteToken = CurrencyAmount.fromRawAmount(quoteToken, 0);
+        }
+        else {
+            gasCostQuoteToken = getQuoteThroughNativePool(chainId, costNativeCurrency, nativePool);
+        }
+    }
+    // Adjust quote for gas fees
+    let quoteGasAdjusted;
+    if (route.trade.tradeType == TradeType.EXACT_OUTPUT) {
+        // Exact output - need more of tokenIn to get the desired amount of tokenOut
+        quoteGasAdjusted = route.quote.add(gasCostQuoteToken);
+    }
+    else {
+        // Exact input - can get less of tokenOut due to fees
+        quoteGasAdjusted = route.quote.subtract(gasCostQuoteToken);
+    }
+    return {
+        estimatedGasUsedUSD: gasCostUSD,
+        estimatedGasUsedQuoteToken: gasCostQuoteToken,
+        estimatedGasUsedGasToken: gasCostInTermsOfGasToken,
+        quoteGasAdjusted: quoteGasAdjusted,
+    };
+}
+export function initSwapRouteFromExisting(swapRoute, v2PoolProvider, v3PoolProvider, v4PoolProvider, portionProvider, quoteGasAdjusted, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, swapOptions, estimatedGasUsedGasToken, providerConfig) {
+    const currencyIn = swapRoute.trade.inputAmount.currency;
+    const currencyOut = swapRoute.trade.outputAmount.currency;
+    const fewTokenIn = isFewToken(swapRoute.trade.inputAmount.currency.wrapped) ?
+        currencyIn.wrapped :
+        getFewTokenFromOriginalToken(swapRoute.trade.inputAmount.currency.wrapped, currencyIn.chainId);
+    const fewTokenOut = isFewToken(swapRoute.trade.outputAmount.currency.wrapped) ?
+        currencyOut.wrapped :
+        getFewTokenFromOriginalToken(swapRoute.trade.outputAmount.currency.wrapped, currencyOut.chainId);
+    const tradeType = swapRoute.trade.tradeType.valueOf()
+        ? TradeType.EXACT_OUTPUT
+        : TradeType.EXACT_INPUT;
+    const routesWithValidQuote = swapRoute.route.map((route) => {
+        switch (route.protocol) {
+            case Protocol.V4:
+                return new V4RouteWithValidQuote({
+                    amount: CurrencyAmount.fromFractionalAmount(route.amount.currency, route.amount.numerator, route.amount.denominator),
+                    rawQuote: BigNumber.from(route.rawQuote),
+                    sqrtPriceX96AfterList: route.sqrtPriceX96AfterList.map((num) => BigNumber.from(num)),
+                    initializedTicksCrossedList: [...route.initializedTicksCrossedList],
+                    quoterGasEstimate: BigNumber.from(route.gasEstimate),
+                    percent: route.percent,
+                    route: route.route,
+                    gasModel: route.gasModel,
+                    quoteToken: new Token(currencyIn.chainId, route.quoteToken.address, route.quoteToken.decimals, route.quoteToken.symbol, route.quoteToken.name),
+                    tradeType: tradeType,
+                    v4PoolProvider: v4PoolProvider,
+                });
+            case Protocol.V3:
+                return new V3RouteWithValidQuote({
+                    amount: CurrencyAmount.fromFractionalAmount(route.amount.currency, route.amount.numerator, route.amount.denominator),
+                    rawQuote: BigNumber.from(route.rawQuote),
+                    sqrtPriceX96AfterList: route.sqrtPriceX96AfterList.map((num) => BigNumber.from(num)),
+                    initializedTicksCrossedList: [...route.initializedTicksCrossedList],
+                    quoterGasEstimate: BigNumber.from(route.gasEstimate),
+                    percent: route.percent,
+                    route: route.route,
+                    gasModel: route.gasModel,
+                    quoteToken: new Token(currencyIn.chainId, route.quoteToken.address, route.quoteToken.decimals, route.quoteToken.symbol, route.quoteToken.name),
+                    tradeType: tradeType,
+                    v3PoolProvider: v3PoolProvider,
+                });
+            case Protocol.V2:
+                return new V2RouteWithValidQuote({
+                    amount: CurrencyAmount.fromFractionalAmount(route.amount.currency, route.amount.numerator, route.amount.denominator),
+                    rawQuote: BigNumber.from(route.rawQuote),
+                    percent: route.percent,
+                    route: route.route,
+                    gasModel: route.gasModel,
+                    quoteToken: new Token(currencyIn.chainId, route.quoteToken.address, route.quoteToken.decimals, route.quoteToken.symbol, route.quoteToken.name),
+                    tradeType: tradeType,
+                    v2PoolProvider: v2PoolProvider,
+                });
+            case Protocol.MIXED:
+                return new MixedRouteWithValidQuote({
+                    amount: CurrencyAmount.fromFractionalAmount(route.amount.currency, route.amount.numerator, route.amount.denominator),
+                    rawQuote: BigNumber.from(route.rawQuote),
+                    sqrtPriceX96AfterList: route.sqrtPriceX96AfterList.map((num) => BigNumber.from(num)),
+                    initializedTicksCrossedList: [...route.initializedTicksCrossedList],
+                    quoterGasEstimate: BigNumber.from(route.gasEstimate),
+                    percent: route.percent,
+                    route: route.route,
+                    mixedRouteGasModel: route.gasModel,
+                    v2PoolProvider,
+                    quoteToken: new Token(currencyIn.chainId, route.quoteToken.address, route.quoteToken.decimals, route.quoteToken.symbol, route.quoteToken.name),
+                    tradeType: tradeType,
+                    v3PoolProvider: v3PoolProvider,
+                    v4PoolProvider: v4PoolProvider,
+                });
+            default:
+                throw new Error('Invalid protocol');
+        }
+    });
+    const trade = buildTrade(currencyIn, fewTokenIn, currencyOut, fewTokenOut, tradeType, routesWithValidQuote);
+    const quoteGasAndPortionAdjusted = swapRoute.portionAmount
+        ? portionProvider.getQuoteGasAndPortionAdjusted(swapRoute.trade.tradeType, quoteGasAdjusted, swapRoute.portionAmount)
+        : undefined;
+    const routesWithValidQuotePortionAdjusted = portionProvider.getRouteWithQuotePortionAdjusted(swapRoute.trade.tradeType, routesWithValidQuote, swapOptions, providerConfig);
+    return {
+        quote: swapRoute.quote,
+        quoteGasAdjusted,
+        quoteGasAndPortionAdjusted,
+        estimatedGasUsed,
+        estimatedGasUsedQuoteToken,
+        estimatedGasUsedGasToken,
+        estimatedGasUsedUSD,
+        gasPriceWei: BigNumber.from(swapRoute.gasPriceWei),
+        trade,
+        route: routesWithValidQuotePortionAdjusted,
+        blockNumber: BigNumber.from(swapRoute.blockNumber),
+        methodParameters: swapRoute.methodParameters
+            ? {
+                calldata: swapRoute.methodParameters.calldata,
+                value: swapRoute.methodParameters.value,
+                to: swapRoute.methodParameters.to,
+            }
+            : undefined,
+        simulationStatus: swapRoute.simulationStatus,
+        portionAmount: swapRoute.portionAmount,
+        hitsCachedRoute: swapRoute.hitsCachedRoute,
+    };
+}
+export const calculateL1GasFeesHelper = async (route, chainId, usdPool, quoteToken, nativePool, provider, l2GasData, providerConfig) => {
+    var _a;
+    const swapOptions = {
+        type: SwapType.UNIVERSAL_ROUTER,
+        version: (_a = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.universalRouterVersion) !== null && _a !== void 0 ? _a : UniversalRouterVersion.V1_2,
+        recipient: '0x0000000000000000000000000000000000000001',
+        deadlineOrPreviousBlockhash: 100,
+        slippageTolerance: new Percent(5, 10000),
+    };
+    let mainnetGasUsed = BigNumber.from(0);
+    let mainnetFeeInWei = BigNumber.from(0);
+    let gasUsedL1OnL2 = BigNumber.from(0);
+    if (opStackChains.includes(chainId)) {
+        [mainnetGasUsed, mainnetFeeInWei] = await calculateOptimismToL1SecurityFee(route, swapOptions, chainId, provider);
+    }
+    else if (chainId == ChainId.ARBITRUM_ONE ||
+        chainId == ChainId.ARBITRUM_GOERLI) {
+        [mainnetGasUsed, mainnetFeeInWei, gasUsedL1OnL2] =
+            calculateArbitrumToL1SecurityFee(route, swapOptions, l2GasData, chainId);
+    }
+    // wrap fee to native currency
+    const nativeCurrency = WRAPPED_NATIVE_CURRENCY[chainId];
+    const costNativeCurrency = CurrencyAmount.fromRawAmount(nativeCurrency, mainnetFeeInWei.toString());
+    // convert fee into usd
+    const fn = (isFewToken(costNativeCurrency.currency) || (usdPool instanceof RingFewPair || usdPool == null)) ? getRingQuoteThroughNativePool : getQuoteThroughNativePool;
+    const gasCostL1USD = fn(chainId, costNativeCurrency, usdPool);
+    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)) {
+        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: mainnetGasUsed,
+        gasUsedL1OnL2,
+        gasCostL1USD,
+        gasCostL1QuoteToken,
+    };
+    /**
+     * 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.
+     */
+    async function calculateOptimismToL1SecurityFee(routes, swapConfig, chainId, provider) {
+        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;
+        const fewTokenIn = isFewToken(amountToken.wrapped) ?
+            amountToken.wrapped :
+            getFewTokenFromOriginalToken(amountToken.wrapped, amountToken.chainId);
+        const fewTokenOut = isFewToken(outputToken.wrapped) ?
+            outputToken.wrapped :
+            getFewTokenFromOriginalToken(outputToken.wrapped, outputToken.chainId);
+        // build trade for swap calldata
+        const trade = buildTrade(amountToken, fewTokenIn, outputToken, fewTokenOut, route.tradeType, routes);
+        const data = buildSwapMethodParameters(trade, swapConfig, ChainId.OPTIMISM).calldata;
+        const [l1GasUsed, l1GasCost] = await calculateOptimismToL1FeeFromCalldata(data, chainId, provider);
+        return [l1GasUsed, l1GasCost];
+    }
+    function calculateArbitrumToL1SecurityFee(routes, swapConfig, gasData, chainId) {
+        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;
+        const fewTokenIn = isFewToken(amountToken.wrapped) ?
+            amountToken.wrapped :
+            getFewTokenFromOriginalToken(amountToken.wrapped, amountToken.chainId);
+        const fewTokenOut = isFewToken(outputToken.wrapped) ?
+            outputToken.wrapped :
+            getFewTokenFromOriginalToken(outputToken.wrapped, outputToken.chainId);
+        // build trade for swap calldata
+        const trade = buildTrade(amountToken, fewTokenIn, outputToken, fewTokenOut, route.tradeType, routes);
+        const data = buildSwapMethodParameters(trade, swapConfig, ChainId.ARBITRUM_ONE).calldata;
+        return calculateArbitrumToL1FeeFromCalldata(data, gasData, chainId);
+    }
+};
+// Logs metrics about the diff between original estimatedGasUsed based on heuristics and the simulated gas used.
+// This will help us track the quality of our gas estimation quality per chain.
+export const logGasEstimationVsSimulationMetrics = (route, simulationGasUsed, chainId) => {
+    try {
+        // Log the diff between original estimatedGasUsed and the simulated gas used
+        const estimatedGasUsed = route.estimatedGasUsed.toNumber();
+        const simulatedGasUsed = simulationGasUsed.toNumber();
+        const diff = estimatedGasUsed - simulatedGasUsed;
+        const absDiff = Math.abs(estimatedGasUsed - simulatedGasUsed);
+        const misEstimatePercent = (diff / estimatedGasUsed) * 100;
+        const misEstimateAbsPercent = (absDiff / estimatedGasUsed) * 100;
+        log.info({
+            estimatedGasUsed: estimatedGasUsed,
+            simulatedGasUsed: simulatedGasUsed,
+            absDiff: absDiff,
+            diff: diff,
+        }, 'Gas used diff between estimatedGasUsed and simulatedGasUsed');
+        log.info({
+            misEstimateAbsPercent: misEstimateAbsPercent,
+        }, 'Gas used mis-estimate percent');
+        metric.putMetric(`TenderlySimulationGasUsed_AbsDiff_Chain_${chainId}`, absDiff, MetricLoggerUnit.Count);
+        metric.putMetric(`TenderlySimulationGasUsed_MisEstimateAbsPercent_Chain_${chainId}`, misEstimateAbsPercent, MetricLoggerUnit.Count);
+        const label = diff >= 0 ? 'OverEstimate' : 'UnderEstimate';
+        metric.putMetric(`TenderlySimulationGasUsed_${label}Percent_Chain_${chainId}`, misEstimatePercent, MetricLoggerUnit.Count);
+    }
+    catch (err) {
+        log.error({ err: err }, 'Failed to log diff between original estimatedGasUsed and the simulated gas used');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gas-factory-helpers.js","sourceRoot":"","sources":["../../../src/util/gas-factory-helpers.ts"],"names":[],"mappings":"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"}

package/build/module/util/hooksOptions.d.ts

@@ -0,0 +1,5 @@
+export declare enum HooksOptions {
+    NO_HOOKS = "NO_HOOKS",
+    HOOKS_ONLY = "HOOKS_ONLY",
+    HOOKS_INCLUSIVE = "HOOKS_INCLUSIVE"
+}

package/build/module/util/hooksOptions.js

@@ -0,0 +1,7 @@
+export var HooksOptions;
+(function (HooksOptions) {
+    HooksOptions["NO_HOOKS"] = "NO_HOOKS";
+    HooksOptions["HOOKS_ONLY"] = "HOOKS_ONLY";
+    HooksOptions["HOOKS_INCLUSIVE"] = "HOOKS_INCLUSIVE";
+})(HooksOptions || (HooksOptions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9va3NPcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWwvaG9va3NPcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFlBSVg7QUFKRCxXQUFZLFlBQVk7SUFDdEIscUNBQXFCLENBQUE7SUFDckIseUNBQXlCLENBQUE7SUFDekIsbURBQW1DLENBQUE7QUFDckMsQ0FBQyxFQUpXLFlBQVksS0FBWixZQUFZLFFBSXZCIn0=

package/build/module/util/index.d.ts

@@ -0,0 +1,10 @@
+export * from './addresses';
+export * from './amounts';
+export * from './chains';
+export * from './hooksOptions';
+export * from './intent';
+export * from './log';
+export * from './metric';
+export * from './pool';
+export * from './protocols';
+export * from './routes';