v-swap-smart-order-router 3.10.2

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

@@ -0,0 +1,132 @@
+import { TradeType } from '@uniswap/sdk-core';
+import { PERMIT2_ADDRESS } from '@uniswap/universal-router-sdk';
+import { BigNumber } from 'ethers/lib/ethers';
+import { SwapType } from '../routers';
+import { Erc20__factory } from '../types/other/factories/Erc20__factory';
+import { Permit2__factory } from '../types/other/factories/Permit2__factory';
+import { log, SWAP_ROUTER_02_ADDRESSES, } from '../util';
+export 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 = {}));
+/**
+ * Provider for dry running transactions.
+ *
+ * @export
+ * @class Simulator
+ */
+export class Simulator {
+    /**
+     * Returns a new SwapRoute with simulated gas estimates
+     * @returns SwapRoute
+     */
+    constructor(provider, chainId) {
+        this.chainId = chainId;
+        this.provider = provider;
+    }
+    async simulate(fromAddress, swapOptions, swapRoute, amount, quote, l2GasData, providerConfig) {
+        if (await this.userHasSufficientBalance(fromAddress, swapRoute.trade.tradeType, amount, quote)) {
+            log.info('User has sufficient balance to simulate. Simulating transaction.');
+            try {
+                return this.simulateTransaction(fromAddress, swapOptions, swapRoute, l2GasData, providerConfig);
+            }
+            catch (e) {
+                log.error({ e }, 'Error simulating transaction');
+                return {
+                    ...swapRoute,
+                    simulationStatus: SimulationStatus.Failed,
+                };
+            }
+        }
+        else {
+            log.error('User does not have sufficient balance to simulate.');
+            return {
+                ...swapRoute,
+                simulationStatus: SimulationStatus.InsufficientBalance,
+            };
+        }
+    }
+    async userHasSufficientBalance(fromAddress, tradeType, amount, quote) {
+        try {
+            const neededBalance = tradeType == TradeType.EXACT_INPUT ? amount : quote;
+            let balance;
+            if (neededBalance.currency.isNative) {
+                balance = await this.provider.getBalance(fromAddress);
+            }
+            else {
+                const tokenContract = Erc20__factory.connect(neededBalance.currency.address, this.provider);
+                balance = await tokenContract.balanceOf(fromAddress);
+            }
+            const hasBalance = balance.gte(BigNumber.from(neededBalance.quotient.toString()));
+            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) {
+            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.connect(inputAmount.currency.wrapped.address, provider);
+        if (swapOptions.type == SwapType.UNIVERSAL_ROUTER) {
+            const permit2Allowance = await tokenContract.allowance(fromAddress, PERMIT2_ADDRESS);
+            // If a permit has been provided we don't need to check if UR has already been allowed.
+            if (swapOptions.inputTokenPermit) {
+                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(BigNumber.from(inputAmount.quotient.toString()));
+            }
+            // Check UR has been approved from Permit2.
+            const permit2Contract = Permit2__factory.connect(PERMIT2_ADDRESS, provider);
+            const { amount: universalRouterAllowance, expiration: tokenExpiration } = await permit2Contract.allowance(fromAddress, inputAmount.currency.wrapped.address, SWAP_ROUTER_02_ADDRESSES(this.chainId));
+            const nowTimestampS = Math.round(Date.now() / 1000);
+            const inputAmountBN = BigNumber.from(inputAmount.quotient.toString());
+            const permit2Approved = permit2Allowance.gte(inputAmountBN);
+            const universalRouterApproved = universalRouterAllowance.gte(inputAmountBN);
+            const expirationValid = tokenExpiration > nowTimestampS;
+            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 == SwapType.SWAP_ROUTER_02) {
+            if (swapOptions.inputTokenPermit) {
+                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, SWAP_ROUTER_02_ADDRESSES(this.chainId));
+            const hasAllowance = allowance.gte(BigNumber.from(inputAmount.quotient.toString()));
+            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}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/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(): Promise<GasPrice>;
+}

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

@@ -0,0 +1,9 @@
+export class StaticGasPriceProvider {
+    constructor(gasPriceWei) {
+        this.gasPriceWei = gasPriceWei;
+    }
+    async getGasPrice() {
+        return { gasPriceWei: this.gasPriceWei };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGljLWdhcy1wcmljZS1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3RhdGljLWdhcy1wcmljZS1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLFlBQW9CLFdBQXNCO1FBQXRCLGdCQUFXLEdBQVgsV0FBVyxDQUFXO0lBQUcsQ0FBQztJQUM5QyxLQUFLLENBQUMsV0FBVztRQUNmLE9BQU8sRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzNDLENBQUM7Q0FDRiJ9

package/build/module/providers/swap-router-provider.d.ts

@@ -0,0 +1,31 @@
+import { ApprovalTypes } from '@uniswap/router-sdk';
+import { Currency, CurrencyAmount } from '@uniswap/sdk-core';
+import { ChainId } from '../util';
+import { IMulticallProvider } from './multicall-provider';
+declare type TokenApprovalTypes = {
+    approvalTokenIn: ApprovalTypes;
+    approvalTokenOut: ApprovalTypes;
+};
+/**
+ * Provider for accessing the SwapRouter02 Contract .
+ *
+ * @export
+ * @interface IRouterProvider
+ */
+export interface ISwapRouterProvider {
+    /**
+     * Get the approval method needed for each token. Throws an error if either query fails.
+     *
+     * @param tokenInAmount The Currency Amount of tokenIn needed by the user
+     * @param tokenOutAmount The Currency Amount of tokenOut needed by the user
+     * @returns the Approval Types for each token.
+     */
+    getApprovalType(tokenInAmount: CurrencyAmount<Currency>, tokenOutAmount: CurrencyAmount<Currency>): Promise<TokenApprovalTypes>;
+}
+export declare class SwapRouterProvider implements ISwapRouterProvider {
+    protected multicall2Provider: IMulticallProvider;
+    protected chainId: ChainId;
+    constructor(multicall2Provider: IMulticallProvider, chainId: ChainId);
+    getApprovalType(tokenInAmount: CurrencyAmount<Currency>, tokenOutAmount: CurrencyAmount<Currency>): Promise<TokenApprovalTypes>;
+}
+export {};

package/build/module/providers/swap-router-provider.js

@@ -0,0 +1,38 @@
+import { SwapRouter02__factory } from '../types/other/factories/SwapRouter02__factory';
+import { log, SWAP_ROUTER_02_ADDRESSES } from '../util';
+export class SwapRouterProvider {
+    constructor(multicall2Provider, chainId) {
+        this.multicall2Provider = multicall2Provider;
+        this.chainId = chainId;
+    }
+    async getApprovalType(tokenInAmount, tokenOutAmount) {
+        var _a, _b;
+        const functionParams = [
+            [
+                tokenInAmount.currency.wrapped.address,
+                tokenInAmount.quotient.toString(),
+            ],
+            [
+                tokenOutAmount.currency.wrapped.address,
+                tokenOutAmount.quotient.toString(),
+            ],
+        ];
+        const tx = await this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+            address: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+            contractInterface: SwapRouter02__factory.createInterface(),
+            functionName: 'getApprovalType',
+            functionParams,
+        });
+        if (!((_a = tx.results[0]) === null || _a === void 0 ? void 0 : _a.success) || !((_b = tx.results[1]) === null || _b === void 0 ? void 0 : _b.success)) {
+            log.info({ results: tx.results }, 'Failed to get approval type from swap router for token in or token out');
+            throw new Error('Failed to get approval type from swap router for token in or token out');
+        }
+        const { result: approvalTokenIn } = tx.results[0];
+        const { result: approvalTokenOut } = tx.results[1];
+        return {
+            approvalTokenIn: approvalTokenIn[0],
+            approvalTokenOut: approvalTokenOut[0],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dhcC1yb3V0ZXItcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N3YXAtcm91dGVyLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQ3ZGLE9BQU8sRUFBVyxHQUFHLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxTQUFTLENBQUM7QUE2QmpFLE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsWUFDWSxrQkFBc0MsRUFDdEMsT0FBZ0I7UUFEaEIsdUJBQWtCLEdBQWxCLGtCQUFrQixDQUFvQjtRQUN0QyxZQUFPLEdBQVAsT0FBTyxDQUFTO0lBQ3pCLENBQUM7SUFFRyxLQUFLLENBQUMsZUFBZSxDQUMxQixhQUF1QyxFQUN2QyxjQUF3Qzs7UUFFeEMsTUFBTSxjQUFjLEdBQXVCO1lBQ3pDO2dCQUNFLGFBQWEsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU87Z0JBQ3RDLGFBQWEsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFO2FBQ2xDO1lBQ0Q7Z0JBQ0UsY0FBYyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsT0FBTztnQkFDdkMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUU7YUFDbkM7U0FDRixDQUFDO1FBRUYsTUFBTSxFQUFFLEdBQ04sTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsNENBQTRDLENBR3hFO1lBQ0EsT0FBTyxFQUFFLHdCQUF3QixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7WUFDL0MsaUJBQWlCLEVBQUUscUJBQXFCLENBQUMsZUFBZSxFQUFFO1lBQzFELFlBQVksRUFBRSxpQkFBaUI7WUFDL0IsY0FBYztTQUNmLENBQUMsQ0FBQztRQUVMLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLEVBQUU7WUFDdEQsR0FBRyxDQUFDLElBQUksQ0FDTixFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQ3ZCLHdFQUF3RSxDQUN6RSxDQUFDO1lBQ0YsTUFBTSxJQUFJLEtBQUssQ0FDYix3RUFBd0UsQ0FDekUsQ0FBQztTQUNIO1FBRUQsTUFBTSxFQUFFLE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELE1BQU0sRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXBELE9BQU87WUFDTCxlQUFlLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztZQUNuQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7U0FDdEMsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9

package/build/module/providers/tenderly-simulation-provider.d.ts

@@ -0,0 +1,45 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { SwapOptions, SwapRoute } from '../routers';
+import { ChainId } from '../util';
+import { EthEstimateGasSimulator } from './eth-estimate-gas-provider';
+import { ProviderConfig } from './provider';
+import { SimulationResult, Simulator } from './simulation-provider';
+import { IV2PoolProvider } from './v2/pool-provider';
+import { ArbitrumGasData, OptimismGasData } from './v3/gas-data-provider';
+import { IV3PoolProvider } from './v3/pool-provider';
+export declare type TenderlyResponseUniversalRouter = {
+    config: {
+        url: string;
+        method: string;
+        data: string;
+    };
+    simulation_results: [SimulationResult, SimulationResult, SimulationResult];
+};
+export declare type TenderlyResponseSwapRouter02 = {
+    config: {
+        url: string;
+        method: string;
+        data: string;
+    };
+    simulation_results: [SimulationResult, SimulationResult];
+};
+export declare class FallbackTenderlySimulator extends Simulator {
+    private tenderlySimulator;
+    private ethEstimateGasSimulator;
+    constructor(chainId: ChainId, provider: JsonRpcProvider, tenderlySimulator: TenderlySimulator, ethEstimateGasSimulator: EthEstimateGasSimulator);
+    protected simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, l2GasData?: ArbitrumGasData | OptimismGasData, providerConfig?: ProviderConfig): Promise<SwapRoute>;
+}
+export declare class TenderlySimulator extends Simulator {
+    private tenderlyBaseUrl;
+    private tenderlyUser;
+    private tenderlyProject;
+    private tenderlyAccessKey;
+    private v2PoolProvider;
+    private v3PoolProvider;
+    private overrideEstimateMultiplier;
+    constructor(chainId: ChainId, tenderlyBaseUrl: string, tenderlyUser: string, tenderlyProject: string, tenderlyAccessKey: string, v2PoolProvider: IV2PoolProvider, v3PoolProvider: IV3PoolProvider, provider: JsonRpcProvider, overrideEstimateMultiplier?: {
+        [chainId in ChainId]?: number;
+    });
+    simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, l2GasData?: ArbitrumGasData | OptimismGasData, providerConfig?: ProviderConfig): Promise<SwapRoute>;
+    private logTenderlyErrorResponse;
+}

package/build/module/providers/tenderly-simulation-provider.js

@@ -0,0 +1,249 @@
+import { MaxUint256 } from '@ethersproject/constants';
+import { PERMIT2_ADDRESS, UNIVERSAL_ROUTER_ADDRESS, } from '@uniswap/universal-router-sdk';
+import axios from 'axios';
+import { BigNumber } from 'ethers/lib/ethers';
+import { SwapType } from '../routers';
+import { Erc20__factory } from '../types/other/factories/Erc20__factory';
+import { Permit2__factory } from '../types/other/factories/Permit2__factory';
+import { ChainId, log, MAX_UINT160, SWAP_ROUTER_02_ADDRESSES } from '../util';
+import { APPROVE_TOKEN_FOR_TRANSFER } from '../util/callData';
+import { calculateGasUsed, initSwapRouteFromExisting, } from '../util/gas-factory-helpers';
+import { SimulationStatus, Simulator, } from './simulation-provider';
+const TENDERLY_BATCH_SIMULATE_API = (tenderlyBaseUrl, tenderlyUser, tenderlyProject) => `${tenderlyBaseUrl}/api/v1/account/${tenderlyUser}/project/${tenderlyProject}/simulate-batch`;
+// We multiply tenderly gas limit by this to overestimate gas limit
+const DEFAULT_ESTIMATE_MULTIPLIER = 1.25;
+export class FallbackTenderlySimulator extends Simulator {
+    constructor(chainId, provider, tenderlySimulator, ethEstimateGasSimulator) {
+        super(provider, chainId);
+        this.tenderlySimulator = tenderlySimulator;
+        this.ethEstimateGasSimulator = ethEstimateGasSimulator;
+    }
+    async simulateTransaction(fromAddress, swapOptions, swapRoute, l2GasData, providerConfig) {
+        // Make call to eth estimate gas if possible
+        // For erc20s, we must check if the token allowance is sufficient
+        const inputAmount = swapRoute.trade.inputAmount;
+        if (inputAmount.currency.isNative ||
+            (await this.checkTokenApproved(fromAddress, inputAmount, swapOptions, this.provider))) {
+            log.info('Simulating with eth_estimateGas since token is native or approved.');
+            try {
+                const swapRouteWithGasEstimate = await this.ethEstimateGasSimulator.ethEstimateGas(fromAddress, swapOptions, swapRoute, l2GasData);
+                return swapRouteWithGasEstimate;
+            }
+            catch (err) {
+                log.info({ err: err }, 'Error simulating using eth_estimateGas');
+                return { ...swapRoute, simulationStatus: SimulationStatus.Failed };
+            }
+        }
+        try {
+            return await this.tenderlySimulator.simulateTransaction(fromAddress, swapOptions, swapRoute, l2GasData, providerConfig);
+        }
+        catch (err) {
+            log.info({ err: err }, 'Failed to simulate via Tenderly');
+            return { ...swapRoute, simulationStatus: SimulationStatus.Failed };
+        }
+    }
+}
+export class TenderlySimulator extends Simulator {
+    constructor(chainId, tenderlyBaseUrl, tenderlyUser, tenderlyProject, tenderlyAccessKey, v2PoolProvider, v3PoolProvider, provider, overrideEstimateMultiplier) {
+        super(provider, chainId);
+        this.tenderlyBaseUrl = tenderlyBaseUrl;
+        this.tenderlyUser = tenderlyUser;
+        this.tenderlyProject = tenderlyProject;
+        this.tenderlyAccessKey = tenderlyAccessKey;
+        this.v2PoolProvider = v2PoolProvider;
+        this.v3PoolProvider = v3PoolProvider;
+        this.overrideEstimateMultiplier = overrideEstimateMultiplier !== null && overrideEstimateMultiplier !== void 0 ? overrideEstimateMultiplier : {};
+    }
+    async simulateTransaction(fromAddress, swapOptions, swapRoute, l2GasData, providerConfig) {
+        var _a;
+        const currencyIn = swapRoute.trade.inputAmount.currency;
+        const tokenIn = currencyIn.wrapped;
+        const chainId = this.chainId;
+        if ([ChainId.CELO, ChainId.CELO_ALFAJORES].includes(chainId)) {
+            const msg = 'Celo not supported by Tenderly!';
+            log.info(msg);
+            return { ...swapRoute, simulationStatus: SimulationStatus.NotSupported };
+        }
+        if (!swapRoute.methodParameters) {
+            const msg = 'No calldata provided to simulate transaction';
+            log.info(msg);
+            throw new Error(msg);
+        }
+        const { calldata } = swapRoute.methodParameters;
+        log.info({
+            calldata: swapRoute.methodParameters.calldata,
+            fromAddress: fromAddress,
+            chainId: chainId,
+            tokenInAddress: tokenIn.address,
+            router: swapOptions.type,
+        }, 'Simulating transaction on Tenderly');
+        const blockNumber = await (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber);
+        let estimatedGasUsed;
+        const estimateMultiplier = (_a = this.overrideEstimateMultiplier[chainId]) !== null && _a !== void 0 ? _a : DEFAULT_ESTIMATE_MULTIPLIER;
+        if (swapOptions.type == SwapType.UNIVERSAL_ROUTER) {
+            // Do initial onboarding approval of Permit2.
+            const erc20Interface = Erc20__factory.createInterface();
+            const approvePermit2Calldata = erc20Interface.encodeFunctionData('approve', [PERMIT2_ADDRESS, MaxUint256]);
+            // We are unsure if the users calldata contains a permit or not. We just
+            // max approve the Univeral Router from Permit2 instead, which will cover both cases.
+            const permit2Interface = Permit2__factory.createInterface();
+            const approveUniversalRouterCallData = permit2Interface.encodeFunctionData('approve', [
+                tokenIn.address,
+                UNIVERSAL_ROUTER_ADDRESS(this.chainId),
+                MAX_UINT160,
+                Math.floor(new Date().getTime() / 1000) + 10000000,
+            ]);
+            const approvePermit2 = {
+                network_id: chainId,
+                gas_estimate: true,
+                input: approvePermit2Calldata,
+                to: tokenIn.address,
+                value: '0',
+                from: fromAddress,
+            };
+            const approveUniversalRouter = {
+                network_id: chainId,
+                gas_estimate: true,
+                input: approveUniversalRouterCallData,
+                to: PERMIT2_ADDRESS,
+                value: '0',
+                from: fromAddress,
+            };
+            const swap = {
+                network_id: chainId,
+                input: calldata,
+                gas_estimate: true,
+                to: UNIVERSAL_ROUTER_ADDRESS(this.chainId),
+                value: currencyIn.isNative ? swapRoute.methodParameters.value : '0',
+                from: fromAddress,
+                // TODO: This is a Temporary fix given by Tenderly team, remove once resolved on their end.
+                block_number: chainId == ChainId.ARBITRUM_ONE && blockNumber
+                    ? blockNumber - 5
+                    : undefined,
+            };
+            const body = {
+                simulations: [approvePermit2, approveUniversalRouter, swap],
+                gas_estimate: true,
+            };
+            const opts = {
+                headers: {
+                    'X-Access-Key': this.tenderlyAccessKey,
+                },
+            };
+            const url = TENDERLY_BATCH_SIMULATE_API(this.tenderlyBaseUrl, this.tenderlyUser, this.tenderlyProject);
+            const resp = (await axios.post(url, body, opts)).data;
+            // Validate tenderly response body
+            if (!resp ||
+                resp.simulation_results.length < 3 ||
+                !resp.simulation_results[2].transaction ||
+                resp.simulation_results[2].transaction.error_message) {
+                this.logTenderlyErrorResponse(resp);
+                return { ...swapRoute, simulationStatus: SimulationStatus.Failed };
+            }
+            // Parse the gas used in the simulation response object, and then pad it so that we overestimate.
+            estimatedGasUsed = BigNumber.from((resp.simulation_results[2].transaction.gas_used * estimateMultiplier).toFixed(0));
+            log.info({
+                body,
+                approvePermit2GasUsed: resp.simulation_results[0].transaction.gas_used,
+                approveUniversalRouterGasUsed: resp.simulation_results[1].transaction.gas_used,
+                swapGasUsed: resp.simulation_results[2].transaction.gas_used,
+                swapWithMultiplier: estimatedGasUsed.toString(),
+            }, 'Successfully Simulated Approvals + Swap via Tenderly for Universal Router. Gas used.');
+            log.info({ swapTransaction: resp.simulation_results[2].transaction }, 'Successful Tenderly Swap Transaction for Universal Router');
+            log.info({ swapSimulation: resp.simulation_results[2].simulation }, 'Successful Tenderly Swap Simulation for Universal Router');
+        }
+        else if (swapOptions.type == SwapType.SWAP_ROUTER_02) {
+            const approve = {
+                network_id: chainId,
+                input: APPROVE_TOKEN_FOR_TRANSFER,
+                gas_estimate: true,
+                to: tokenIn.address,
+                value: '0',
+                from: fromAddress,
+            };
+            const swap = {
+                network_id: chainId,
+                input: calldata,
+                to: SWAP_ROUTER_02_ADDRESSES(chainId),
+                gas_estimate: true,
+                value: currencyIn.isNative ? swapRoute.methodParameters.value : '0',
+                from: fromAddress,
+                // TODO: This is a Temporary fix given by Tenderly team, remove once resolved on their end.
+                block_number: chainId == ChainId.ARBITRUM_ONE && blockNumber
+                    ? blockNumber - 5
+                    : undefined,
+            };
+            const body = { simulations: [approve, swap] };
+            const opts = {
+                headers: {
+                    'X-Access-Key': this.tenderlyAccessKey,
+                },
+            };
+            const url = TENDERLY_BATCH_SIMULATE_API(this.tenderlyBaseUrl, this.tenderlyUser, this.tenderlyProject);
+            const resp = (await axios.post(url, body, opts)).data;
+            // Validate tenderly response body
+            if (!resp ||
+                resp.simulation_results.length < 2 ||
+                !resp.simulation_results[1].transaction ||
+                resp.simulation_results[1].transaction.error_message) {
+                const msg = `Failed to Simulate Via Tenderly!: ${resp.simulation_results[1].transaction.error_message}`;
+                log.info({ err: resp.simulation_results[1].transaction.error_message }, msg);
+                return { ...swapRoute, simulationStatus: SimulationStatus.Failed };
+            }
+            // Parse the gas used in the simulation response object, and then pad it so that we overestimate.
+            estimatedGasUsed = BigNumber.from((resp.simulation_results[1].transaction.gas_used * estimateMultiplier).toFixed(0));
+            log.info({
+                body,
+                approveGasUsed: resp.simulation_results[0].transaction.gas_used,
+                swapGasUsed: resp.simulation_results[1].transaction.gas_used,
+                swapWithMultiplier: estimatedGasUsed.toString(),
+            }, 'Successfully Simulated Approval + Swap via Tenderly for SwapRouter02. Gas used.');
+            log.info({ swapTransaction: resp.simulation_results[1].transaction }, 'Successful Tenderly Swap Transaction for SwapRouter02');
+            log.info({ swapSimulation: resp.simulation_results[1].simulation }, 'Successful Tenderly Swap Simulation for SwapRouter02');
+        }
+        else {
+            throw new Error(`Unsupported swap type: ${swapOptions}`);
+        }
+        const { estimatedGasUsedUSD, estimatedGasUsedQuoteToken, quoteGasAdjusted, } = await calculateGasUsed(chainId, swapRoute, estimatedGasUsed, this.v2PoolProvider, this.v3PoolProvider, l2GasData);
+        return {
+            ...initSwapRouteFromExisting(swapRoute, this.v2PoolProvider, this.v3PoolProvider, quoteGasAdjusted, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD),
+            simulationStatus: SimulationStatus.Succeeded,
+        };
+    }
+    logTenderlyErrorResponse(resp) {
+        log.info({
+            resp,
+        }, 'Failed to Simulate on Tenderly');
+        log.info({
+            err: resp.simulation_results.length >= 1
+                ? resp.simulation_results[0].transaction
+                : {},
+        }, 'Failed to Simulate on Tenderly #1 Transaction');
+        log.info({
+            err: resp.simulation_results.length >= 1
+                ? resp.simulation_results[0].simulation
+                : {},
+        }, 'Failed to Simulate on Tenderly #1 Simulation');
+        log.info({
+            err: resp.simulation_results.length >= 2
+                ? resp.simulation_results[1].transaction
+                : {},
+        }, 'Failed to Simulate on Tenderly #2 Transaction');
+        log.info({
+            err: resp.simulation_results.length >= 2
+                ? resp.simulation_results[1].simulation
+                : {},
+        }, 'Failed to Simulate on Tenderly #2 Simulation');
+        log.info({
+            err: resp.simulation_results.length >= 3
+                ? resp.simulation_results[2].transaction
+                : {},
+        }, 'Failed to Simulate on Tenderly #3 Transaction');
+        log.info({
+            err: resp.simulation_results.length >= 3
+                ? resp.simulation_results[2].simulation
+                : {},
+        }, 'Failed to Simulate on Tenderly #3 Simulation');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenderly-simulation-provider.js","sourceRoot":"","sources":["../../../src/providers/tenderly-simulation-provider.ts"],"names":[],"mappings":"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"}