@kumbaya_xyz/smart-order-router 4.22.38

package/build/main/providers/pool-provider.d.ts

@@ -0,0 +1,45 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId, Currency } from '@uniswap/sdk-core';
+import { Pool as V3Pool } from '@uniswap/v3-sdk';
+import { Pool as V4Pool } from '@uniswap/v4-sdk';
+import { Options as RetryOptions } from 'async-retry';
+import { IMulticallProvider, Result } from './multicall-provider';
+import { ProviderConfig } from './provider';
+export type PoolConstruct<TCurrency extends Currency> = [
+    TCurrency,
+    TCurrency,
+    ...Array<string | number>
+];
+export type Pool = V3Pool | V4Pool;
+export type ISlot0 = {
+    sqrtPriceX96: BigNumber;
+    tick: number;
+};
+export type ILiquidity = {
+    liquidity: BigNumber;
+};
+export declare abstract class PoolProvider<TCurrency extends Currency, TPoolConstruct extends PoolConstruct<TCurrency>, TISlot0 extends ISlot0, TILiquidity extends ILiquidity, TPoolAccessor> {
+    protected chainId: ChainId;
+    protected multicall2Provider: IMulticallProvider;
+    protected retryOptions: RetryOptions;
+    /**
+     * Creates an instance of V4PoolProvider.
+     * @param chainId The chain id to use.
+     * @param multicall2Provider The multicall provider to use to get the pools.
+     * @param retryOptions The retry options for each call to the multicall.
+     */
+    constructor(chainId: ChainId, multicall2Provider: IMulticallProvider, retryOptions?: RetryOptions);
+    protected getPoolsInternal(poolConstructs: TPoolConstruct[], providerConfig?: ProviderConfig): Promise<TPoolAccessor>;
+    protected abstract getLiquidityFunctionName(): string;
+    protected abstract getSlot0FunctionName(): string;
+    protected abstract getPoolsData<TReturn>(poolIdentifiers: string[], functionName: string, providerConfig?: ProviderConfig): Promise<Result<TReturn>[]>;
+    protected abstract getPoolIdentifier(pool: TPoolConstruct): {
+        poolIdentifier: string;
+        currency0: TCurrency;
+        currency1: TCurrency;
+    };
+    protected abstract instantiatePool(pool: TPoolConstruct, slot0: TISlot0, liquidity: TILiquidity): Pool;
+    protected abstract instantiatePoolAccessor(poolIdentifierToPool: {
+        [poolId: string]: Pool;
+    }): TPoolAccessor;
+}

package/build/main/providers/pool-provider.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolProvider = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const util_1 = require("../util");
+class PoolProvider {
+    /**
+     * Creates an instance of V4PoolProvider.
+     * @param chainId The chain id to use.
+     * @param multicall2Provider The multicall provider to use to get the pools.
+     * @param retryOptions The retry options for each call to the multicall.
+     */
+    constructor(chainId, multicall2Provider, retryOptions = {
+        retries: 2,
+        minTimeout: 50,
+        maxTimeout: 500,
+    }) {
+        this.chainId = chainId;
+        this.multicall2Provider = multicall2Provider;
+        this.retryOptions = retryOptions;
+    }
+    async getPoolsInternal(poolConstructs, providerConfig) {
+        const poolIdentifierSet = new Set();
+        const sortedCurrencyPairs = [];
+        const sortedPoolIdentifiers = [];
+        for (const poolConstruct of poolConstructs) {
+            const { poolIdentifier: poolIdentifier, currency0, currency1, } = this.getPoolIdentifier(poolConstruct);
+            if (poolIdentifierSet.has(poolIdentifier)) {
+                continue;
+            }
+            // It's the easiest way to change the pool construct in place, since we don't know the entire pool construct at compiling time.
+            poolConstruct[0] = currency0;
+            poolConstruct[1] = currency1;
+            poolIdentifierSet.add(poolIdentifier);
+            sortedCurrencyPairs.push(poolConstruct);
+            sortedPoolIdentifiers.push(poolIdentifier);
+        }
+        util_1.log.debug(`getPools called with ${poolConstructs.length} token pairs. Deduped down to ${poolIdentifierSet.size}`);
+        const [slot0Results, liquidityResults] = await Promise.all([
+            this.getPoolsData(sortedPoolIdentifiers, this.getSlot0FunctionName(), providerConfig),
+            this.getPoolsData(sortedPoolIdentifiers, this.getLiquidityFunctionName(), providerConfig),
+        ]);
+        util_1.log.info(`Got liquidity and slot0s for ${poolIdentifierSet.size} pools ${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? `as of block: ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}.`
+            : ``}`);
+        const poolIdentifierToPool = {};
+        const invalidPools = [];
+        for (let i = 0; i < sortedPoolIdentifiers.length; i++) {
+            const slot0Result = slot0Results[i];
+            const liquidityResult = liquidityResults[i];
+            // These properties tell us if a pool is valid and initialized or not.
+            if (!(slot0Result === null || slot0Result === void 0 ? void 0 : slot0Result.success) ||
+                !(liquidityResult === null || liquidityResult === void 0 ? void 0 : liquidityResult.success) ||
+                slot0Result.result.sqrtPriceX96.eq(0)) {
+                invalidPools.push(sortedCurrencyPairs[i]);
+                continue;
+            }
+            const slot0 = slot0Result.result;
+            const liquidity = liquidityResult.result[0];
+            const pool = this.instantiatePool(sortedCurrencyPairs[i], slot0, liquidity);
+            const poolIdentifier = sortedPoolIdentifiers[i];
+            poolIdentifierToPool[poolIdentifier] = pool;
+        }
+        const poolStrs = lodash_1.default.map(Object.values(poolIdentifierToPool), util_1.poolToString);
+        util_1.log.debug({ poolStrs }, `Found ${poolStrs.length} valid pools`);
+        return this.instantiatePoolAccessor(poolIdentifierToPool);
+    }
+}
+exports.PoolProvider = PoolProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/providers/portion-provider.d.ts

@@ -0,0 +1,86 @@
+import { TradeType } from '@uniswap/sdk-core';
+import { RouteWithValidQuote, SwapOptions } from '../routers';
+import { CurrencyAmount } from '../util';
+import { ProviderConfig } from './provider';
+export interface IPortionProvider {
+    /**
+     * Get the portion amount for the given token out amount.
+     * portion amount is always calculated against the token out amount.
+     *
+     * @param tokenOutAmount the token out amount, either the quote for exact in, or the swapper requested amount for exact out
+     * @param tradeType the trade type, exact in or exact out
+     * @param externalTransferFailed fees charged on token transfers where the to or from address is NOT the uniswap V2 pair address
+     * @param feeTakenOnTransfer double fee taken on transfer as part of universal router custody
+     * @param swapConfig swap config, containing the portion related data
+     */
+    getPortionAmount(tokenOutAmount: CurrencyAmount, tradeType: TradeType, externalTransferFailed?: boolean, feeTakenOnTransfer?: boolean, swapConfig?: SwapOptions): CurrencyAmount | undefined;
+    /**
+     * Get the portion quote amount for the given portion amount.
+     * Only applicable for exact out. For exact out, will return zero amount.
+     *
+     * @param tradeType the trade type, exact in or exact out
+     * @param quote token in amount for exact out.
+     * @param amount swapper request amount for exact out.
+     * @param portionAmount the portion amount
+     */
+    getPortionQuoteAmount(tradeType: TradeType, quote: CurrencyAmount, amount: CurrencyAmount, portionAmount?: CurrencyAmount): CurrencyAmount | undefined;
+    /**
+     * In-place update the route quote amount with the portion amount deducted.
+     * This method is only applicable for exact in.
+     * For exact out, the portion amount gets added into the swapper requested amount at the beginning of
+     * `AlphaRouter.route(...)` method.
+     *
+     * For exact in, the portion amount gets subtracted from the quote amount at the end of
+     * get best swap route.
+     *
+     * @param tradeType the trade type, exact in or exact out
+     * @param routeWithQuotes the route with quotes
+     * @param swapConfig swap config, containing the portion related data
+     * @param providerConfig provider config, for the FOT fee related data
+     */
+    getRouteWithQuotePortionAdjusted(tradeType: TradeType, routeWithQuotes: RouteWithValidQuote[], swapConfig?: SwapOptions, providerConfig?: ProviderConfig): RouteWithValidQuote[];
+    /**
+     * Get the quote gas adjusted amount for exact in and exact out.
+     * For exact in, quote amount is the same as the best swap quote.
+     * For exact out, quote amount is the best swap quote minus the portion quote token amount.
+     * The reason is SOR adds the portion amount into the exact out swapper requested amount.
+     * SOR needs to estimate the equivalent portion quote token amount, and have quote amount subtract portion quote token amount.
+     *
+     * @param tradeType the trade type, exact in or exact out
+     * @param quote the best swap quote
+     * @param portionQuoteAmount the portion quote token amount
+     */
+    getQuote(tradeType: TradeType, quote: CurrencyAmount, portionQuoteAmount?: CurrencyAmount): CurrencyAmount;
+    /**
+     * Get the quote gas adjusted amount for exact in and exact out.
+     * For exact in, quote gas adjusted amount is the same as the best swap quote gas adjusted amount.
+     * For exact out, quote gas adjusted amount is the best swap quote gas adjusted amount minus the portion quote token amount.
+     * The reason is SOR adds the portion amount into the exact out swapper requested amount.
+     * SOR needs to estimate the equivalent portion quote token amount, and have quote gas adjusted amount subtract portion quote token amount.
+     *
+     * @param tradeType the trade type, exact in or exact out
+     * @param quoteGasAdjusted the best swap quote gas adjusted amount
+     * @param portionQuoteAmount the portion quote token amount
+     */
+    getQuoteGasAdjusted(tradeType: TradeType, quoteGasAdjusted: CurrencyAmount, portionQuoteAmount?: CurrencyAmount): CurrencyAmount;
+    /**
+     * Get the quote gas and portion adjusted amount for exact in and exact out.
+     * For exact in, quote gas and portion adjusted amount is the best swap quote gas adjusted amount minus the portion amount.
+     * The reason is because quote gas and portion adjusted amount for exact in does not know anything about portion.
+     * For exact out, quote gas and portion adjusted amount is the best swap quote gas adjusted amount.
+     * The reason is because quote gas and portion adjusted amount for exact out has already added the portion quote token amount.
+     *
+     * @param tradeType
+     * @param quoteGasAdjusted
+     * @param portionAmount
+     */
+    getQuoteGasAndPortionAdjusted(tradeType: TradeType, quoteGasAdjusted: CurrencyAmount, portionAmount?: CurrencyAmount): CurrencyAmount | undefined;
+}
+export declare class PortionProvider implements IPortionProvider {
+    getPortionAmount(tokenOutAmount: CurrencyAmount, tradeType: TradeType, externalTransferFailed?: boolean, feeTakenOnTransfer?: boolean, swapConfig?: SwapOptions): CurrencyAmount | undefined;
+    getPortionQuoteAmount(tradeType: TradeType, quote: CurrencyAmount, portionAdjustedAmount: CurrencyAmount, portionAmount?: CurrencyAmount): CurrencyAmount | undefined;
+    getRouteWithQuotePortionAdjusted(tradeType: TradeType, routeWithQuotes: RouteWithValidQuote[], swapConfig?: SwapOptions, providerConfig?: ProviderConfig): RouteWithValidQuote[];
+    getQuote(tradeType: TradeType, quote: CurrencyAmount, portionQuoteAmount?: CurrencyAmount): CurrencyAmount;
+    getQuoteGasAdjusted(tradeType: TradeType, quoteGasAdjusted: CurrencyAmount, portionQuoteAmount?: CurrencyAmount): CurrencyAmount;
+    getQuoteGasAndPortionAdjusted(tradeType: TradeType, quoteGasAdjusted: CurrencyAmount, portionAmount?: CurrencyAmount): CurrencyAmount | undefined;
+}

package/build/main/providers/portion-provider.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortionProvider = void 0;
+const bignumber_1 = require("@ethersproject/bignumber");
+const router_sdk_1 = require("@uniswap/router-sdk");
+const sdk_core_1 = require("@uniswap/sdk-core");
+const routers_1 = require("../routers");
+const util_1 = require("../util");
+class PortionProvider {
+    getPortionAmount(tokenOutAmount, tradeType, externalTransferFailed, feeTakenOnTransfer, swapConfig) {
+        if (externalTransferFailed ||
+            feeTakenOnTransfer ||
+            (swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.type) !== routers_1.SwapType.UNIVERSAL_ROUTER) {
+            return undefined;
+        }
+        const swapConfigUniversalRouter = swapConfig;
+        switch (tradeType) {
+            case sdk_core_1.TradeType.EXACT_INPUT:
+                if (swapConfigUniversalRouter.fee &&
+                    swapConfigUniversalRouter.fee.fee.greaterThan(router_sdk_1.ZERO)) {
+                    return tokenOutAmount.multiply(swapConfigUniversalRouter.fee.fee);
+                }
+                return undefined;
+            case sdk_core_1.TradeType.EXACT_OUTPUT:
+                if (swapConfigUniversalRouter.flatFee &&
+                    swapConfigUniversalRouter.flatFee.amount > bignumber_1.BigNumber.from(0)) {
+                    return util_1.CurrencyAmount.fromRawAmount(tokenOutAmount.currency, swapConfigUniversalRouter.flatFee.amount.toString());
+                }
+                return undefined;
+            default:
+                throw new Error(`Unknown trade type ${tradeType}`);
+        }
+    }
+    getPortionQuoteAmount(tradeType, quote, portionAdjustedAmount, portionAmount) {
+        if (!portionAmount) {
+            return undefined;
+        }
+        // this method can only be called for exact out
+        // for exact in, there is no need to compute the portion quote amount, since portion is always against token out amount
+        if (tradeType !== sdk_core_1.TradeType.EXACT_OUTPUT) {
+            return undefined;
+        }
+        // 1. then we know portion amount and portion adjusted exact out amount,
+        //    we can get a ratio
+        //    i.e. portionToPortionAdjustedAmountRatio = portionAmountToken / portionAdjustedAmount
+        const portionToPortionAdjustedAmountRatio = new sdk_core_1.Fraction(portionAmount.quotient, portionAdjustedAmount.quotient);
+        // 2. we have the portionAmountToken / portionAdjustedAmount ratio
+        //    then we can estimate the portion amount for quote, i.e. what is the estimated token in amount deducted for the portion
+        //    this amount will be portionQuoteAmountToken = portionAmountToken / portionAdjustedAmount * quote
+        //    CAVEAT: we prefer to use the quote currency amount OVER quote gas adjusted currency amount for the formula
+        //    because the portion amount calculated from the exact out has no way to account for the gas units.
+        return util_1.CurrencyAmount.fromRawAmount(quote.currency, portionToPortionAdjustedAmountRatio.multiply(quote).quotient);
+    }
+    getRouteWithQuotePortionAdjusted(tradeType, routeWithQuotes, swapConfig, providerConfig) {
+        // the route with quote portion adjustment is only needed for exact in routes with quotes
+        // because the route with quotes does not know the output amount needs to subtract the portion amount
+        if (tradeType !== sdk_core_1.TradeType.EXACT_INPUT) {
+            return routeWithQuotes;
+        }
+        // the route with quote portion adjustment is only needed for universal router
+        // for swap router 02, it doesn't have portion-related commands
+        if ((swapConfig === null || swapConfig === void 0 ? void 0 : swapConfig.type) !== routers_1.SwapType.UNIVERSAL_ROUTER) {
+            return routeWithQuotes;
+        }
+        return routeWithQuotes.map((routeWithQuote) => {
+            const portionAmount = this.getPortionAmount(routeWithQuote.quote, tradeType, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.externalTransferFailed, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.feeTakenOnTransfer, swapConfig);
+            // This is a sub-optimal solution agreed among the teams to work around the exact in
+            // portion amount issue for universal router.
+            // The most optimal solution is to update router-sdk https://github.com/Uniswap/router-sdk/blob/main/src/entities/trade.ts#L215
+            // `minimumAmountOut` to include portionBips as well, `public minimumAmountOut(slippageTolerance: Percent, amountOut = this.outputAmount, portionBips: Percent)
+            // but this will require a new release of router-sdk, and bump router-sdk versions in across downstream dependencies across the stack.
+            // We opt to use this sub-optimal solution for now, and revisit the optimal solution in the future.
+            // Since SOR subtracts portion amount from EACH route output amount (note the routeWithQuote.quote above),
+            // SOR will have as accurate ouput amount per route as possible, which helps with the final `minimumAmountOut`
+            if (portionAmount) {
+                routeWithQuote.quote = routeWithQuote.quote.subtract(portionAmount);
+            }
+            return routeWithQuote;
+        });
+    }
+    getQuote(tradeType, quote, portionQuoteAmount) {
+        switch (tradeType) {
+            case sdk_core_1.TradeType.EXACT_INPUT:
+                return quote;
+            case sdk_core_1.TradeType.EXACT_OUTPUT:
+                return portionQuoteAmount ? quote.subtract(portionQuoteAmount) : quote;
+            default:
+                throw new Error(`Unknown trade type ${tradeType}`);
+        }
+    }
+    getQuoteGasAdjusted(tradeType, quoteGasAdjusted, portionQuoteAmount) {
+        switch (tradeType) {
+            case sdk_core_1.TradeType.EXACT_INPUT:
+                return quoteGasAdjusted;
+            case sdk_core_1.TradeType.EXACT_OUTPUT:
+                return portionQuoteAmount
+                    ? quoteGasAdjusted.subtract(portionQuoteAmount)
+                    : quoteGasAdjusted;
+            default:
+                throw new Error(`Unknown trade type ${tradeType}`);
+        }
+    }
+    getQuoteGasAndPortionAdjusted(tradeType, quoteGasAdjusted, portionAmount) {
+        if (!portionAmount) {
+            return undefined;
+        }
+        switch (tradeType) {
+            case sdk_core_1.TradeType.EXACT_INPUT:
+                return quoteGasAdjusted.subtract(portionAmount);
+            case sdk_core_1.TradeType.EXACT_OUTPUT:
+                return quoteGasAdjusted;
+            default:
+                throw new Error(`Unknown trade type ${tradeType}`);
+        }
+    }
+}
+exports.PortionProvider = PortionProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/providers/provider.d.ts

@@ -0,0 +1,38 @@
+import { UniversalRouterVersion } from '@uniswap/universal-router-sdk';
+export type ProviderConfig = {
+    /**
+     * The block number to use when getting data on-chain.
+     */
+    blockNumber?: number | Promise<number>;
+    debugRouting?: boolean;
+    /**
+     * Flag for token properties provider to enable fetching fee-on-transfer tokens.
+     */
+    enableFeeOnTransferFeeFetching?: boolean;
+    /**
+     * Tenderly natively support save simulation failures if failed,
+     * we need this as a pass-through flag to enable/disable this feature.
+     */
+    saveTenderlySimulationIfFailed?: boolean;
+    /**
+     * Flag to indicate whether to use the CachedRoutes in optimistic mode.
+     * Optimistic mode means that we will allow blocksToLive greater than 1.
+     */
+    optimisticCachedRoutes?: boolean;
+    /**
+     * FOT fees charged on token transfers where the to or from address is NOT the uniswap V2 pair address
+     */
+    externalTransferFailed?: boolean;
+    /**
+     * double FOT fee taken on transfer as part of universal router custody
+     */
+    feeTakenOnTransfer?: boolean;
+    /**
+     * The version of the universal router to use.
+     */
+    universalRouterVersion?: UniversalRouterVersion;
+};
+export type LocalCacheEntry<T> = {
+    entry: T;
+    blockNumber: number;
+};

package/build/main/providers/provider.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/build/main/providers/simulation-provider.d.ts

@@ -0,0 +1,46 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId, TradeType } from '@uniswap/sdk-core';
+import { GasModelProviderConfig, SwapOptions, SwapRoute } from '../routers';
+import { CurrencyAmount } from '../util';
+import { IPortionProvider } from './portion-provider';
+export type SimulationResult = {
+    transaction: {
+        hash: string;
+        gas_used: number;
+        gas: number;
+        error_message: string;
+    };
+    simulation: {
+        state_overrides: Record<string, unknown>;
+    };
+};
+export declare enum SimulationStatus {
+    NotSupported = 0,
+    Failed = 1,
+    Succeeded = 2,
+    InsufficientBalance = 3,
+    NotApproved = 4,
+    SystemDown = 5,
+    SlippageTooLow = 6,
+    TransferFromFailed = 7
+}
+/**
+ * Provider for dry running transactions.
+ *
+ * @export
+ * @class Simulator
+ */
+export declare abstract class Simulator {
+    protected chainId: ChainId;
+    protected provider: JsonRpcProvider;
+    protected portionProvider: IPortionProvider;
+    /**
+     * Returns a new SwapRoute with simulated gas estimates
+     * @returns SwapRoute
+     */
+    constructor(provider: JsonRpcProvider, portionProvider: IPortionProvider, chainId: ChainId);
+    simulate(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, amount: CurrencyAmount, quote: CurrencyAmount, providerConfig?: GasModelProviderConfig): Promise<SwapRoute>;
+    protected abstract simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, providerConfig?: GasModelProviderConfig): Promise<SwapRoute>;
+    protected userHasSufficientBalance(fromAddress: string, tradeType: TradeType, amount: CurrencyAmount, quote: CurrencyAmount): Promise<boolean>;
+    protected checkTokenApproved(fromAddress: string, inputAmount: CurrencyAmount, swapOptions: SwapOptions, provider: JsonRpcProvider): Promise<boolean>;
+}

package/build/main/providers/simulation-provider.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = exports.SimulationStatus = void 0;
+const permit2_sdk_1 = require("@uniswap/permit2-sdk");
+const sdk_core_1 = require("@uniswap/sdk-core");
+const ethers_1 = require("ethers/lib/ethers");
+const routers_1 = require("../routers");
+const Erc20__factory_1 = require("../types/other/factories/Erc20__factory");
+const Permit2__factory_1 = require("../types/other/factories/Permit2__factory");
+const util_1 = require("../util");
+var SimulationStatus;
+(function (SimulationStatus) {
+    SimulationStatus[SimulationStatus["NotSupported"] = 0] = "NotSupported";
+    SimulationStatus[SimulationStatus["Failed"] = 1] = "Failed";
+    SimulationStatus[SimulationStatus["Succeeded"] = 2] = "Succeeded";
+    SimulationStatus[SimulationStatus["InsufficientBalance"] = 3] = "InsufficientBalance";
+    SimulationStatus[SimulationStatus["NotApproved"] = 4] = "NotApproved";
+    SimulationStatus[SimulationStatus["SystemDown"] = 5] = "SystemDown";
+    SimulationStatus[SimulationStatus["SlippageTooLow"] = 6] = "SlippageTooLow";
+    SimulationStatus[SimulationStatus["TransferFromFailed"] = 7] = "TransferFromFailed";
+})(SimulationStatus = exports.SimulationStatus || (exports.SimulationStatus = {}));
+/**
+ * Provider for dry running transactions.
+ *
+ * @export
+ * @class Simulator
+ */
+class Simulator {
+    /**
+     * Returns a new SwapRoute with simulated gas estimates
+     * @returns SwapRoute
+     */
+    constructor(provider, portionProvider, chainId) {
+        this.chainId = chainId;
+        this.provider = provider;
+        this.portionProvider = portionProvider;
+    }
+    async simulate(fromAddress, swapOptions, swapRoute, amount, quote, providerConfig) {
+        const neededBalance = swapRoute.trade.tradeType == sdk_core_1.TradeType.EXACT_INPUT ? amount : quote;
+        if (
+        // we assume we always have enough eth mainnet balance because we use beacon address later
+        (neededBalance.currency.isNative && this.chainId == sdk_core_1.ChainId.MAINNET) ||
+            (await this.userHasSufficientBalance(fromAddress, swapRoute.trade.tradeType, amount, quote))) {
+            util_1.log.info('User has sufficient balance to simulate. Simulating transaction.');
+            try {
+                return this.simulateTransaction(fromAddress, swapOptions, swapRoute, providerConfig);
+            }
+            catch (e) {
+                util_1.log.error({ e }, 'Error simulating transaction');
+                return Object.assign(Object.assign({}, swapRoute), { simulationStatus: SimulationStatus.Failed });
+            }
+        }
+        else {
+            util_1.log.error('User does not have sufficient balance to simulate.');
+            return Object.assign(Object.assign({}, swapRoute), { simulationStatus: SimulationStatus.InsufficientBalance });
+        }
+    }
+    async userHasSufficientBalance(fromAddress, tradeType, amount, quote) {
+        try {
+            const neededBalance = tradeType == sdk_core_1.TradeType.EXACT_INPUT ? amount : quote;
+            let balance;
+            if (neededBalance.currency.isNative) {
+                balance = await this.provider.getBalance(fromAddress);
+            }
+            else {
+                const tokenContract = Erc20__factory_1.Erc20__factory.connect(neededBalance.currency.address, this.provider);
+                balance = await tokenContract.balanceOf(fromAddress);
+            }
+            const hasBalance = balance.gte(ethers_1.BigNumber.from(neededBalance.quotient.toString()));
+            util_1.log.info({
+                fromAddress,
+                balance: balance.toString(),
+                neededBalance: neededBalance.quotient.toString(),
+                neededAddress: neededBalance.wrapped.currency.address,
+                hasBalance,
+            }, 'Result of balance check for simulation');
+            return hasBalance;
+        }
+        catch (e) {
+            util_1.log.error(e, 'Error while checking user balance');
+            return false;
+        }
+    }
+    async checkTokenApproved(fromAddress, inputAmount, swapOptions, provider) {
+        // Check token has approved Permit2 more than expected amount.
+        const tokenContract = Erc20__factory_1.Erc20__factory.connect(inputAmount.currency.wrapped.address, provider);
+        if (swapOptions.type == routers_1.SwapType.UNIVERSAL_ROUTER) {
+            const permit2Allowance = await tokenContract.allowance(fromAddress, (0, permit2_sdk_1.permit2Address)(this.chainId));
+            // If a permit has been provided we don't need to check if UR has already been allowed.
+            if (swapOptions.inputTokenPermit) {
+                util_1.log.info({
+                    permitAllowance: permit2Allowance.toString(),
+                    inputAmount: inputAmount.quotient.toString(),
+                }, 'Permit was provided for simulation on UR, checking that Permit2 has been approved.');
+                return permit2Allowance.gte(ethers_1.BigNumber.from(inputAmount.quotient.toString()));
+            }
+            // Check UR has been approved from Permit2.
+            const permit2Contract = Permit2__factory_1.Permit2__factory.connect((0, permit2_sdk_1.permit2Address)(this.chainId), provider);
+            const { amount: universalRouterAllowance, expiration: tokenExpiration } = await permit2Contract.allowance(fromAddress, inputAmount.currency.wrapped.address, (0, util_1.SWAP_ROUTER_02_ADDRESSES)(this.chainId));
+            const nowTimestampS = Math.round(Date.now() / 1000);
+            const inputAmountBN = ethers_1.BigNumber.from(inputAmount.quotient.toString());
+            const permit2Approved = permit2Allowance.gte(inputAmountBN);
+            const universalRouterApproved = universalRouterAllowance.gte(inputAmountBN);
+            const expirationValid = tokenExpiration > nowTimestampS;
+            util_1.log.info({
+                permitAllowance: permit2Allowance.toString(),
+                tokenAllowance: universalRouterAllowance.toString(),
+                tokenExpirationS: tokenExpiration,
+                nowTimestampS,
+                inputAmount: inputAmount.quotient.toString(),
+                permit2Approved,
+                universalRouterApproved,
+                expirationValid,
+            }, `Simulating on UR, Permit2 approved: ${permit2Approved}, UR approved: ${universalRouterApproved}, Expiraton valid: ${expirationValid}.`);
+            return permit2Approved && universalRouterApproved && expirationValid;
+        }
+        else if (swapOptions.type == routers_1.SwapType.SWAP_ROUTER_02) {
+            if (swapOptions.inputTokenPermit) {
+                util_1.log.info({
+                    inputAmount: inputAmount.quotient.toString(),
+                }, 'Simulating on SwapRouter02 info - Permit was provided for simulation. Not checking allowances.');
+                return true;
+            }
+            const allowance = await tokenContract.allowance(fromAddress, (0, util_1.SWAP_ROUTER_02_ADDRESSES)(this.chainId));
+            const hasAllowance = allowance.gte(ethers_1.BigNumber.from(inputAmount.quotient.toString()));
+            util_1.log.info({
+                hasAllowance,
+                allowance: allowance.toString(),
+                inputAmount: inputAmount.quotient.toString(),
+            }, `Simulating on SwapRouter02 - Has allowance: ${hasAllowance}`);
+            // Return true if token allowance is greater than input amount
+            return hasAllowance;
+        }
+        throw new Error(`Unsupported swap type ${swapOptions}`);
+    }
+}
+exports.Simulator = Simulator;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/providers/static-gas-price-provider.d.ts

@@ -0,0 +1,7 @@
+import { BigNumber } from 'ethers';
+import { GasPrice, IGasPriceProvider } from './gas-price-provider';
+export declare class StaticGasPriceProvider implements IGasPriceProvider {
+    private gasPriceWei;
+    constructor(gasPriceWei: BigNumber);
+    getGasPrice(_latestBlockNumber: number, _requestBlockNumber?: number): Promise<GasPrice>;
+}

package/build/main/providers/static-gas-price-provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticGasPriceProvider = void 0;
+class StaticGasPriceProvider {
+    constructor(gasPriceWei) {
+        this.gasPriceWei = gasPriceWei;
+    }
+    async getGasPrice(_latestBlockNumber, _requestBlockNumber) {
+        return { gasPriceWei: this.gasPriceWei };
+    }
+}
+exports.StaticGasPriceProvider = StaticGasPriceProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGljLWdhcy1wcmljZS1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3RhdGljLWdhcy1wcmljZS1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFLQSxNQUFhLHNCQUFzQjtJQUNqQyxZQUFvQixXQUFzQjtRQUF0QixnQkFBVyxHQUFYLFdBQVcsQ0FBVztJQUFHLENBQUM7SUFFOUMsS0FBSyxDQUFDLFdBQVcsQ0FDZixrQkFBMEIsRUFDMUIsbUJBQTRCO1FBRTVCLE9BQU8sRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzNDLENBQUM7Q0FDRjtBQVRELHdEQVNDIn0=

package/build/main/providers/subgraph-provider-with-fallback.d.ts

@@ -0,0 +1,11 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { Token } from '@uniswap/sdk-core';
+import { SubgraphPool } from '../routers/alpha-router/functions/get-candidate-pools';
+import { ProviderConfig } from './provider';
+import { ISubgraphProvider } from './subgraph-provider';
+export declare abstract class SubgraphProviderWithFallBacks<TSubgraphPool extends SubgraphPool> implements ISubgraphProvider<TSubgraphPool> {
+    private fallbacks;
+    private protocol;
+    protected constructor(fallbacks: ISubgraphProvider<TSubgraphPool>[], protocol: Protocol);
+    getPools(currencyIn?: Token, currencyOut?: Token, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+}

package/build/main/providers/subgraph-provider-with-fallback.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgraphProviderWithFallBacks = void 0;
+const util_1 = require("../util");
+class SubgraphProviderWithFallBacks {
+    constructor(fallbacks, protocol) {
+        this.fallbacks = fallbacks;
+        this.protocol = protocol;
+    }
+    async getPools(currencyIn, currencyOut, providerConfig) {
+        for (let i = 0; i < this.fallbacks.length; i++) {
+            const provider = this.fallbacks[i];
+            try {
+                const pools = await provider.getPools(currencyIn, currencyOut, providerConfig);
+                return pools;
+            }
+            catch (err) {
+                util_1.log.info(`Failed to get subgraph pools for ${this.protocol} from fallback #${i}`);
+            }
+        }
+        throw new Error('Failed to get subgraph pools from any providers');
+    }
+}
+exports.SubgraphProviderWithFallBacks = SubgraphProviderWithFallBacks;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxrQ0FBOEI7QUFLOUIsTUFBc0IsNkJBQTZCO0lBSWpELFlBQ1UsU0FBNkMsRUFDN0MsUUFBa0I7UUFEbEIsY0FBUyxHQUFULFNBQVMsQ0FBb0M7UUFDN0MsYUFBUSxHQUFSLFFBQVEsQ0FBVTtJQUN6QixDQUFDO0lBRUcsS0FBSyxDQUFDLFFBQVEsQ0FDbkIsVUFBa0IsRUFDbEIsV0FBbUIsRUFDbkIsY0FBK0I7UUFFL0IsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQzlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFFLENBQUM7WUFDcEMsSUFBSTtnQkFDRixNQUFNLEtBQUssR0FBRyxNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQ25DLFVBQVUsRUFDVixXQUFXLEVBQ1gsY0FBYyxDQUNmLENBQUM7Z0JBQ0YsT0FBTyxLQUFLLENBQUM7YUFDZDtZQUFDLE9BQU8sR0FBRyxFQUFFO2dCQUNaLFVBQUcsQ0FBQyxJQUFJLENBQ04sb0NBQW9DLElBQUksQ0FBQyxRQUFRLG1CQUFtQixDQUFDLEVBQUUsQ0FDeEUsQ0FBQzthQUNIO1NBQ0Y7UUFFRCxNQUFNLElBQUksS0FBSyxDQUFDLGlEQUFpRCxDQUFDLENBQUM7SUFDckUsQ0FBQztDQUNGO0FBaENELHNFQWdDQyJ9