v-swap-smart-order-router 3.10.2

package/build/module/util/gas-factory-helpers.d.ts

@@ -0,0 +1,24 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Currency, CurrencyAmount, Token } from '@uniswap/sdk-core';
+import { Pair } from '@uniswap/v2-sdk/dist/entities';
+import { Pool } from '@uniswap/v3-sdk';
+import { IV2PoolProvider } from '../providers';
+import { ArbitrumGasData, OptimismGasData } from '../providers/v3/gas-data-provider';
+import { IV3PoolProvider } from '../providers/v3/pool-provider';
+import { SwapRoute } from '../routers';
+import { ChainId } from '../util';
+export declare function getV2NativePool(token: Token, poolProvider: IV2PoolProvider): Promise<Pair | null>;
+export declare function getHighestLiquidityV3NativePool(token: Token, poolProvider: IV3PoolProvider): Promise<Pool | null>;
+export declare function getHighestLiquidityV3USDPool(chainId: ChainId, poolProvider: IV3PoolProvider): Promise<Pool>;
+export declare function getGasCostInUSD(usdPool: Pool, costNativeCurrency: CurrencyAmount<Token>): CurrencyAmount<Token>;
+export declare function getGasCostInNativeCurrency(nativeCurrency: Token, gasCostInWei: BigNumber): CurrencyAmount<Token>;
+export declare function getGasCostInQuoteToken(quoteToken: Token, nativePool: Pool | Pair, costNativeCurrency: CurrencyAmount<Token>): Promise<CurrencyAmount<Token>>;
+export declare function calculateArbitrumToL1FeeFromCalldata(calldata: string, gasData: ArbitrumGasData): [BigNumber, BigNumber];
+export declare function calculateOptimismToL1FeeFromCalldata(calldata: string, gasData: OptimismGasData): [BigNumber, BigNumber];
+export declare function getL2ToL1GasUsed(data: string, overhead: BigNumber): BigNumber;
+export declare function calculateGasUsed(chainId: ChainId, route: SwapRoute, simulatedGasUsed: BigNumber, v2PoolProvider: IV2PoolProvider, v3PoolProvider: IV3PoolProvider, l2GasData?: ArbitrumGasData | OptimismGasData): Promise<{
+    estimatedGasUsedUSD: CurrencyAmount<Token>;
+    estimatedGasUsedQuoteToken: CurrencyAmount<Token>;
+    quoteGasAdjusted: CurrencyAmount<Currency>;
+}>;
+export declare function initSwapRouteFromExisting(swapRoute: SwapRoute, v2PoolProvider: IV2PoolProvider, v3PoolProvider: IV3PoolProvider, quoteGasAdjusted: CurrencyAmount<Currency>, estimatedGasUsed: BigNumber, estimatedGasUsedQuoteToken: CurrencyAmount<Currency>, estimatedGasUsedUSD: CurrencyAmount<Currency>): SwapRoute;

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

@@ -0,0 +1,291 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Protocol } from '@uniswap/router-sdk';
+import { CurrencyAmount, Token, TradeType } from '@uniswap/sdk-core';
+import { FeeAmount } from '@uniswap/v3-sdk';
+import _ from 'lodash';
+import { MixedRouteWithValidQuote, usdGasTokensByChain, V2RouteWithValidQuote, V3RouteWithValidQuote, } from '../routers';
+import { ChainId, log, WRAPPED_NATIVE_CURRENCY } from '../util';
+import { buildTrade } from './methodParameters';
+export async function getV2NativePool(token, poolProvider) {
+    const chainId = token.chainId;
+    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 V2 pool with ${token.symbol} for computing gas costs.`);
+        return null;
+    }
+    return pool;
+}
+export async function getHighestLiquidityV3NativePool(token, poolProvider) {
+    const nativeCurrency = WRAPPED_NATIVE_CURRENCY[token.chainId];
+    const nativePools = _([
+        FeeAmount.HIGH,
+        FeeAmount.MEDIUM,
+        FeeAmount.LOW,
+        FeeAmount.LOWEST,
+    ])
+        .map((feeAmount) => {
+        return [nativeCurrency, token, feeAmount];
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(nativePools);
+    const pools = _([
+        FeeAmount.HIGH,
+        FeeAmount.MEDIUM,
+        FeeAmount.LOW,
+        FeeAmount.LOWEST,
+    ])
+        .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 = _.maxBy(pools, (pool) => pool.liquidity);
+    return maxPool;
+}
+export async function getHighestLiquidityV3USDPool(chainId, poolProvider) {
+    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 usdPools = _([
+        FeeAmount.HIGH,
+        FeeAmount.MEDIUM,
+        FeeAmount.LOW,
+        FeeAmount.LOWEST,
+    ])
+        .flatMap((feeAmount) => {
+        return _.map(usdTokens, (usdToken) => [
+            wrappedCurrency,
+            usdToken,
+            feeAmount,
+        ]);
+    })
+        .value();
+    const poolAccessor = await poolProvider.getPools(usdPools);
+    const pools = _([
+        FeeAmount.HIGH,
+        FeeAmount.MEDIUM,
+        FeeAmount.LOW,
+        FeeAmount.LOWEST,
+    ])
+        .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);
+    }
+    const maxPool = _.maxBy(pools, (pool) => pool.liquidity);
+    return maxPool;
+}
+export function getGasCostInUSD(usdPool, costNativeCurrency) {
+    const nativeCurrency = costNativeCurrency.currency;
+    // convert fee into usd
+    const nativeTokenPrice = usdPool.token0.address == nativeCurrency.address
+        ? usdPool.token0Price
+        : usdPool.token1Price;
+    const gasCostUSD = nativeTokenPrice.quote(costNativeCurrency);
+    return gasCostUSD;
+}
+export function getGasCostInNativeCurrency(nativeCurrency, gasCostInWei) {
+    // wrap fee to native currency
+    const costNativeCurrency = CurrencyAmount.fromRawAmount(nativeCurrency, gasCostInWei.toString());
+    return costNativeCurrency;
+}
+export async function getGasCostInQuoteToken(quoteToken, nativePool, costNativeCurrency) {
+    const nativeTokenPrice = nativePool.token0.address == quoteToken.address
+        ? nativePool.token1Price
+        : nativePool.token0Price;
+    const gasCostQuoteToken = nativeTokenPrice.quote(costNativeCurrency);
+    return gasCostQuoteToken;
+}
+export function calculateArbitrumToL1FeeFromCalldata(calldata, gasData) {
+    const { perL2TxFee, perL1CalldataFee } = gasData;
+    // calculates gas amounts based on bytes of calldata, use 0 as overhead.
+    const l1GasUsed = getL2ToL1GasUsed(calldata, BigNumber.from(0));
+    // multiply by the fee per calldata and add the flat l2 fee
+    let l1Fee = l1GasUsed.mul(perL1CalldataFee);
+    l1Fee = l1Fee.add(perL2TxFee);
+    return [l1GasUsed, l1Fee];
+}
+export function calculateOptimismToL1FeeFromCalldata(calldata, gasData) {
+    const { l1BaseFee, scalar, decimals, overhead } = gasData;
+    const l1GasUsed = getL2ToL1GasUsed(calldata, overhead);
+    // l1BaseFee is L1 Gas Price on etherscan
+    const l1Fee = l1GasUsed.mul(l1BaseFee);
+    const unscaled = l1Fee.mul(scalar);
+    // scaled = unscaled / (10 ** decimals)
+    const scaledConversion = BigNumber.from(10).pow(decimals);
+    const scaled = unscaled.div(scaledConversion);
+    return [l1GasUsed, scaled];
+}
+// based on the code from the optimism OVM_GasPriceOracle contract
+export function getL2ToL1GasUsed(data, overhead) {
+    // data is hex encoded
+    const dataArr = data.slice(2).match(/.{1,2}/g);
+    const numBytes = dataArr.length;
+    let count = 0;
+    for (let i = 0; i < numBytes; i += 1) {
+        const byte = parseInt(dataArr[i], 16);
+        if (byte == 0) {
+            count += 4;
+        }
+        else {
+            count += 16;
+        }
+    }
+    const unsigned = overhead.add(count);
+    const signedConversion = 68 * 16;
+    return unsigned.add(signedConversion);
+}
+export async function calculateGasUsed(chainId, route, simulatedGasUsed, v2PoolProvider, v3PoolProvider, l2GasData) {
+    const quoteToken = route.quote.currency.wrapped;
+    const gasPriceWei = route.gasPriceWei;
+    // calculate L2 to L1 security fee if relevant
+    let l2toL1FeeInWei = BigNumber.from(0);
+    if ([
+        ChainId.ARBITRUM_ONE,
+        ChainId.ARBITRUM_RINKEBY,
+        ChainId.ARBITRUM_GOERLI,
+    ].includes(chainId)) {
+        l2toL1FeeInWei = calculateArbitrumToL1FeeFromCalldata(route.methodParameters.calldata, l2GasData)[1];
+    }
+    else if ([
+        ChainId.OPTIMISM,
+        ChainId.OPTIMISTIC_KOVAN,
+        ChainId.OPTIMISM_GOERLI,
+    ].includes(chainId)) {
+        l2toL1FeeInWei = calculateOptimismToL1FeeFromCalldata(route.methodParameters.calldata, l2GasData)[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);
+    const gasCostUSD = await getGasCostInUSD(usdPool, costNativeCurrency);
+    let gasCostQuoteToken = costNativeCurrency;
+    // get fee in terms of quote token
+    if (!quoteToken.equals(nativeCurrency)) {
+        const nativePools = await Promise.all([
+            getHighestLiquidityV3NativePool(quoteToken, v3PoolProvider),
+            getV2NativePool(quoteToken, v2PoolProvider),
+        ]);
+        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 = await getGasCostInQuoteToken(quoteToken, nativePool, costNativeCurrency);
+        }
+    }
+    // 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,
+        quoteGasAdjusted: quoteGasAdjusted,
+    };
+}
+export function initSwapRouteFromExisting(swapRoute, v2PoolProvider, v3PoolProvider, quoteGasAdjusted, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD) {
+    const currencyIn = swapRoute.trade.inputAmount.currency;
+    const currencyOut = swapRoute.trade.outputAmount.currency;
+    const tradeType = swapRoute.trade.tradeType.valueOf()
+        ? TradeType.EXACT_OUTPUT
+        : TradeType.EXACT_INPUT;
+    const routesWithValidQuote = swapRoute.route.map((route) => {
+        switch (route.protocol) {
+            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,
+                });
+        }
+    });
+    const trade = buildTrade(currencyIn, currencyOut, tradeType, routesWithValidQuote);
+    return {
+        quote: swapRoute.quote,
+        quoteGasAdjusted,
+        estimatedGasUsed,
+        estimatedGasUsedQuoteToken,
+        estimatedGasUsedUSD,
+        gasPriceWei: BigNumber.from(swapRoute.gasPriceWei),
+        trade,
+        route: routesWithValidQuote,
+        blockNumber: BigNumber.from(swapRoute.blockNumber),
+        methodParameters: swapRoute.methodParameters
+            ? {
+                calldata: swapRoute.methodParameters.calldata,
+                value: swapRoute.methodParameters.value,
+                to: swapRoute.methodParameters.to,
+            }
+            : undefined,
+        simulationStatus: swapRoute.simulationStatus,
+    };
+}
+//# 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/index.d.ts

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

package/build/module/util/index.js

@@ -0,0 +1,8 @@
+export * from './addresses';
+export * from './amounts';
+export * from './chains';
+export * from './log';
+export * from './metric';
+export * from './protocols';
+export * from './routes';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFVBQVUsQ0FBQyJ9

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

@@ -0,0 +1,3 @@
+import Logger from 'bunyan';
+export declare let log: Logger;
+export declare const setGlobalLogger: (_log: Logger) => void;

package/build/module/util/log.js

@@ -0,0 +1,93 @@
+/* eslint-disable */
+class NullLogger {
+    constructor() {
+        this.ERROR_MESSAGE = 'NullLogger does not support. Instantiate a valid logger using "setGlobalLogger"';
+        this.src = true;
+    }
+    addStream(_stream) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    addSerializers(_serializers) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    child(_options, _simple) {
+        return this;
+    }
+    reopenFileStreams() {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    level(_value) {
+        return;
+    }
+    levels(_name, _value) {
+        return;
+    }
+    trace(..._rest) {
+        return true;
+    }
+    debug(..._rest) {
+        return true;
+    }
+    info(..._rest) {
+        return true;
+    }
+    warn(..._rest) {
+        return true;
+    }
+    error(..._rest) {
+        return true;
+    }
+    fatal(..._rest) {
+        return true;
+    }
+    addListener(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    on(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    once(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    removeListener(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    off(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    removeAllListeners(_event) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    setMaxListeners(_n) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    getMaxListeners() {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    listeners(_event) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    rawListeners(_event) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    emit(_event, ..._args) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    listenerCount(_event) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    prependListener(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    prependOnceListener(_event, _listener) {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+    eventNames() {
+        throw new Error(this.ERROR_MESSAGE);
+    }
+}
+export let log = new NullLogger();
+export const setGlobalLogger = (_log) => {
+    log = _log;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+import { Trade } from '@uniswap/router-sdk';
+import { Currency, TradeType } from '@uniswap/sdk-core';
+import { ChainId, MethodParameters, RouteWithValidQuote, SwapOptions } from '..';
+export declare function buildTrade<TTradeType extends TradeType>(tokenInCurrency: Currency, tokenOutCurrency: Currency, tradeType: TTradeType, routeAmounts: RouteWithValidQuote[]): Trade<Currency, Currency, TTradeType>;
+export declare function buildSwapMethodParameters(trade: Trade<Currency, Currency, TradeType>, swapConfig: SwapOptions, chainId: ChainId): MethodParameters;

package/build/module/util/methodParameters.js

@@ -0,0 +1,106 @@
+import { MixedRouteSDK, Protocol, SwapRouter as SwapRouter02, Trade, } from '@uniswap/router-sdk';
+import { TradeType } from '@uniswap/sdk-core';
+import { SwapRouter as UniveralRouter, UNIVERSAL_ROUTER_ADDRESS, } from '@uniswap/universal-router-sdk';
+import { Route as V2RouteRaw } from '@uniswap/v2-sdk';
+import { Route as V3RouteRaw } from '@uniswap/v3-sdk';
+import _ from 'lodash';
+import { CurrencyAmount, SwapType, SWAP_ROUTER_02_ADDRESSES, } from '..';
+export function buildTrade(tokenInCurrency, tokenOutCurrency, tradeType, routeAmounts) {
+    /// Removed partition because of new mixedRoutes
+    const v3RouteAmounts = _.filter(routeAmounts, (routeAmount) => routeAmount.protocol === Protocol.V3);
+    const v2RouteAmounts = _.filter(routeAmounts, (routeAmount) => routeAmount.protocol === Protocol.V2);
+    const mixedRouteAmounts = _.filter(routeAmounts, (routeAmount) => routeAmount.protocol === Protocol.MIXED);
+    const v3Routes = _.map(v3RouteAmounts, (routeAmount) => {
+        const { route, amount, quote } = routeAmount;
+        // The route, amount and quote are all in terms of wrapped tokens.
+        // When constructing the Trade object the inputAmount/outputAmount must
+        // use native currencies if specified by the user. This is so that the Trade knows to wrap/unwrap.
+        if (tradeType == TradeType.EXACT_INPUT) {
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, amount.numerator, amount.denominator);
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, quote.numerator, quote.denominator);
+            const routeRaw = new V3RouteRaw(route.pools, amountCurrency.currency, quoteCurrency.currency);
+            return {
+                routev3: routeRaw,
+                inputAmount: amountCurrency,
+                outputAmount: quoteCurrency,
+            };
+        }
+        else {
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, quote.numerator, quote.denominator);
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, amount.numerator, amount.denominator);
+            const routeCurrency = new V3RouteRaw(route.pools, quoteCurrency.currency, amountCurrency.currency);
+            return {
+                routev3: routeCurrency,
+                inputAmount: quoteCurrency,
+                outputAmount: amountCurrency,
+            };
+        }
+    });
+    const v2Routes = _.map(v2RouteAmounts, (routeAmount) => {
+        const { route, amount, quote } = routeAmount;
+        // The route, amount and quote are all in terms of wrapped tokens.
+        // When constructing the Trade object the inputAmount/outputAmount must
+        // use native currencies if specified by the user. This is so that the Trade knows to wrap/unwrap.
+        if (tradeType == TradeType.EXACT_INPUT) {
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, amount.numerator, amount.denominator);
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, quote.numerator, quote.denominator);
+            const routeV2SDK = new V2RouteRaw(route.pairs, amountCurrency.currency, quoteCurrency.currency);
+            return {
+                routev2: routeV2SDK,
+                inputAmount: amountCurrency,
+                outputAmount: quoteCurrency,
+            };
+        }
+        else {
+            const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, quote.numerator, quote.denominator);
+            const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, amount.numerator, amount.denominator);
+            const routeV2SDK = new V2RouteRaw(route.pairs, quoteCurrency.currency, amountCurrency.currency);
+            return {
+                routev2: routeV2SDK,
+                inputAmount: quoteCurrency,
+                outputAmount: amountCurrency,
+            };
+        }
+    });
+    const mixedRoutes = _.map(mixedRouteAmounts, (routeAmount) => {
+        const { route, amount, quote } = routeAmount;
+        if (tradeType != TradeType.EXACT_INPUT) {
+            throw new Error('Mixed routes are only supported for exact input trades');
+        }
+        // The route, amount and quote are all in terms of wrapped tokens.
+        // When constructing the Trade object the inputAmount/outputAmount must
+        // use native currencies if specified by the user. This is so that the Trade knows to wrap/unwrap.
+        const amountCurrency = CurrencyAmount.fromFractionalAmount(tokenInCurrency, amount.numerator, amount.denominator);
+        const quoteCurrency = CurrencyAmount.fromFractionalAmount(tokenOutCurrency, quote.numerator, quote.denominator);
+        const routeRaw = new MixedRouteSDK(route.pools, amountCurrency.currency, quoteCurrency.currency);
+        return {
+            mixedRoute: routeRaw,
+            inputAmount: amountCurrency,
+            outputAmount: quoteCurrency,
+        };
+    });
+    const trade = new Trade({ v2Routes, v3Routes, mixedRoutes, tradeType });
+    return trade;
+}
+export function buildSwapMethodParameters(trade, swapConfig, chainId) {
+    if (swapConfig.type == SwapType.UNIVERSAL_ROUTER) {
+        return {
+            ...UniveralRouter.swapERC20CallParameters(trade, swapConfig),
+            to: UNIVERSAL_ROUTER_ADDRESS(chainId),
+        };
+    }
+    else if (swapConfig.type == SwapType.SWAP_ROUTER_02) {
+        const { recipient, slippageTolerance, deadline, inputTokenPermit } = swapConfig;
+        return {
+            ...SwapRouter02.swapCallParameters(trade, {
+                recipient,
+                slippageTolerance,
+                deadlineOrPreviousBlockhash: deadline,
+                inputTokenPermit,
+            }),
+            to: SWAP_ROUTER_02_ADDRESSES(chainId),
+        };
+    }
+    throw new Error(`Unsupported swap type ${swapConfig}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+export declare enum MetricLoggerUnit {
+    Seconds = "Seconds",
+    Microseconds = "Microseconds",
+    Milliseconds = "Milliseconds",
+    Bytes = "Bytes",
+    Kilobytes = "Kilobytes",
+    Megabytes = "Megabytes",
+    Gigabytes = "Gigabytes",
+    Terabytes = "Terabytes",
+    Bits = "Bits",
+    Kilobits = "Kilobits",
+    Megabits = "Megabits",
+    Gigabits = "Gigabits",
+    Terabits = "Terabits",
+    Percent = "Percent",
+    Count = "Count",
+    BytesPerSecond = "Bytes/Second",
+    KilobytesPerSecond = "Kilobytes/Second",
+    MegabytesPerSecond = "Megabytes/Second",
+    GigabytesPerSecond = "Gigabytes/Second",
+    TerabytesPerSecond = "Terabytes/Second",
+    BitsPerSecond = "Bits/Second",
+    KilobitsPerSecond = "Kilobits/Second",
+    MegabitsPerSecond = "Megabits/Second",
+    GigabitsPerSecond = "Gigabits/Second",
+    TerabitsPerSecond = "Terabits/Second",
+    CountPerSecond = "Count/Second",
+    None = "None"
+}
+export declare abstract class IMetric {
+    abstract setProperty(key: string, value: unknown): void;
+    abstract putDimensions(dimensions: Record<string, string>): void;
+    abstract putMetric(key: string, value: number, unit?: MetricLoggerUnit): void;
+}
+interface MetricContext {
+    chainId: number;
+    networkName: string;
+}
+export declare class MetricLogger extends IMetric {
+    private log;
+    constructor(context?: MetricContext);
+    setProperty(key: string, value: unknown): void;
+    putDimensions(dimensions: Record<string, string>): void;
+    putMetric(key: string, value: number, unit?: MetricLoggerUnit): void;
+}
+export declare let metric: IMetric;
+export declare const setGlobalMetric: (_metric: IMetric) => void;
+export {};