@ring-protocol/smart-order-router 0.5.0

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

@@ -0,0 +1,444 @@
+import { MaxUint256 } from '@ethersproject/constants';
+import { permit2Address } from '@uniswap/permit2-sdk';
+import { ChainId } from '@ring-protocol/sdk-core';
+import { UNIVERSAL_ROUTER_ADDRESS } from '@ring-protocol/universal-router-sdk';
+import axios from 'axios';
+import { BigNumber } from 'ethers/lib/ethers';
+import { metric, MetricLoggerUnit, SwapType, } from '../routers';
+import { Erc20__factory } from '../types/other/factories/Erc20__factory';
+import { Permit2__factory } from '../types/other/factories/Permit2__factory';
+import { BEACON_CHAIN_DEPOSIT_ADDRESS, log, MAX_UINT160, SWAP_ROUTER_02_ADDRESSES, } from '../util';
+import { APPROVE_TOKEN_FOR_TRANSFER } from '../util/callData';
+import { calculateGasUsed, initSwapRouteFromExisting, logGasEstimationVsSimulationMetrics, } from '../util/gas-factory-helpers';
+import { breakDownTenderlySimulationError } from '../util/tenderlySimulationErrorBreakDown';
+import { SimulationStatus, Simulator, } from './simulation-provider';
+// export type TenderlyResponseEstimateGasBundle = {
+//   id: number;
+//   jsonrpc: string;
+//   result: Array<JsonRpcError | GasBody>;
+// };
+var TenderlySimulationType;
+(function (TenderlySimulationType) {
+    TenderlySimulationType["QUICK"] = "quick";
+    TenderlySimulationType["FULL"] = "full";
+    TenderlySimulationType["ABI"] = "abi";
+})(TenderlySimulationType || (TenderlySimulationType = {}));
+const TENDERLY_BATCH_SIMULATE_API = (tenderlyBaseUrl, tenderlyUser, tenderlyProject) => `${tenderlyBaseUrl}/api/v1/account/${tenderlyUser}/project/${tenderlyProject}/simulate-batch`;
+const TENDERLY_NODE_API = (chainId, tenderlyNodeApiKey) => {
+    switch (chainId) {
+        case ChainId.MAINNET:
+            return `https://mainnet.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.BASE:
+            return `https://base.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.ARBITRUM_ONE:
+            return `https://arbitrum.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.OPTIMISM:
+            return `https://optimism.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.POLYGON:
+            return `https://polygon.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.AVALANCHE:
+            return `https://avalanche.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.BLAST:
+            return `https://blast.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.WORLDCHAIN:
+            return `https://worldchain-mainnet.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.UNICHAIN:
+            return `https://unichain.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        case ChainId.SONEIUM:
+            return `https://soneium.gateway.tenderly.co/${tenderlyNodeApiKey}`;
+        default:
+            throw new Error(`ChainId ${chainId} does not correspond to a tenderly node endpoint`);
+    }
+};
+export const TENDERLY_NOT_SUPPORTED_CHAINS = [
+    ChainId.CELO,
+    ChainId.CELO_ALFAJORES,
+    ChainId.ZKSYNC,
+    // tenderly node RPC supports BNB and ZORA upon request, we will make them available
+    ChainId.BNB,
+    ChainId.ZORA,
+    ChainId.MONAD_TESTNET,
+];
+// We multiply tenderly gas limit by this to overestimate gas limit
+const DEFAULT_ESTIMATE_MULTIPLIER = 1.3;
+export class FallbackTenderlySimulator extends Simulator {
+    constructor(chainId, provider, portionProvider, tenderlySimulator, ethEstimateGasSimulator) {
+        super(provider, portionProvider, chainId);
+        this.tenderlySimulator = tenderlySimulator;
+        this.ethEstimateGasSimulator = ethEstimateGasSimulator;
+    }
+    async simulateTransaction(fromAddress, swapOptions, swapRoute, 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, providerConfig);
+                return swapRouteWithGasEstimate;
+            }
+            catch (err) {
+                log.info({ err: err }, 'Error simulating using eth_estimateGas');
+                // If it fails, we should still try to simulate using Tenderly
+                // return { ...swapRoute, simulationStatus: SimulationStatus.Failed };
+            }
+        }
+        try {
+            return await this.tenderlySimulator.simulateTransaction(fromAddress, swapOptions, swapRoute, providerConfig);
+        }
+        catch (err) {
+            log.error({ err: err }, 'Failed to simulate via Tenderly');
+            if (err instanceof Error && err.message.includes('timeout')) {
+                metric.putMetric('TenderlySimulationTimeouts', 1, MetricLoggerUnit.Count);
+            }
+            return { ...swapRoute, simulationStatus: SimulationStatus.SystemDown };
+        }
+    }
+}
+export class TenderlySimulator extends Simulator {
+    constructor(chainId, tenderlyBaseUrl, tenderlyUser, tenderlyProject, tenderlyAccessKey, tenderlyNodeApiKey, v2PoolProvider, v3PoolProvider, v4PoolProvider, provider, portionProvider, overrideEstimateMultiplier, tenderlyRequestTimeout, tenderlyNodeApiMigrationPercent, tenderlyNodeApiEnabledChains) {
+        super(provider, portionProvider, chainId);
+        this.tenderlyNodeApiEnabledChains = [];
+        this.tenderlyBaseUrl = tenderlyBaseUrl;
+        this.tenderlyUser = tenderlyUser;
+        this.tenderlyProject = tenderlyProject;
+        this.tenderlyAccessKey = tenderlyAccessKey;
+        this.tenderlyNodeApiKey = tenderlyNodeApiKey;
+        this.v2PoolProvider = v2PoolProvider;
+        this.v3PoolProvider = v3PoolProvider;
+        this.v4PoolProvider = v4PoolProvider;
+        this.overrideEstimateMultiplier = overrideEstimateMultiplier !== null && overrideEstimateMultiplier !== void 0 ? overrideEstimateMultiplier : {};
+        this.tenderlyRequestTimeout = tenderlyRequestTimeout;
+        this.tenderlyNodeApiMigrationPercent = tenderlyNodeApiMigrationPercent;
+        this.tenderlyNodeApiEnabledChains = tenderlyNodeApiEnabledChains;
+    }
+    async simulateTransaction(fromAddress, swapOptions, swapRoute, providerConfig) {
+        var _a, _b, _c;
+        const currencyIn = swapRoute.trade.inputAmount.currency;
+        const tokenIn = currencyIn.wrapped;
+        const currencyOut = swapRoute.trade.outputAmount.currency;
+        const tokenOut = currencyOut.wrapped;
+        const chainId = this.chainId;
+        if (TENDERLY_NOT_SUPPORTED_CHAINS.includes(chainId)) {
+            const msg = `${TENDERLY_NOT_SUPPORTED_CHAINS.toString()} 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) {
+            // simulating from beacon chain deposit address that should always hold **enough balance**
+            if (currencyIn.isNative && this.chainId == ChainId.MAINNET) {
+                fromAddress = BEACON_CHAIN_DEPOSIT_ADDRESS;
+            }
+            // Do initial onboarding approval of Permit2.
+            const erc20Interface = Erc20__factory.createInterface();
+            const approvePermit2Calldata = erc20Interface.encodeFunctionData('approve', [permit2Address(this.chainId), MaxUint256]);
+            // We are unsure if the users calldata contains a permit or not. We just
+            // max approve the Universal Router from Permit2 instead, which will cover both cases.
+            const permit2Interface = Permit2__factory.createInterface();
+            const approveUniversalRouterCallData = permit2Interface.encodeFunctionData('approve', [
+                tokenIn.address,
+                UNIVERSAL_ROUTER_ADDRESS(swapOptions.version, this.chainId),
+                MAX_UINT160,
+                Math.floor(new Date().getTime() / 1000) + 10000000,
+            ]);
+            const approvePermit2 = {
+                network_id: chainId,
+                estimate_gas: true,
+                input: approvePermit2Calldata,
+                to: tokenIn.address,
+                value: '0',
+                from: fromAddress,
+                block_number: blockNumber,
+                simulation_type: TenderlySimulationType.QUICK,
+                save_if_fails: providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.saveTenderlySimulationIfFailed,
+            };
+            const approveUniversalRouter = {
+                network_id: chainId,
+                estimate_gas: true,
+                input: approveUniversalRouterCallData,
+                to: permit2Address(this.chainId),
+                value: '0',
+                from: fromAddress,
+                block_number: blockNumber,
+                simulation_type: TenderlySimulationType.QUICK,
+                save_if_fails: providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.saveTenderlySimulationIfFailed,
+            };
+            const swap = {
+                network_id: chainId,
+                input: calldata,
+                estimate_gas: true,
+                to: UNIVERSAL_ROUTER_ADDRESS(swapOptions.version, this.chainId),
+                value: currencyIn.isNative ? swapRoute.methodParameters.value : '0',
+                from: fromAddress,
+                block_number: blockNumber,
+                simulation_type: TenderlySimulationType.QUICK,
+                save_if_fails: providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.saveTenderlySimulationIfFailed,
+            };
+            const body = {
+                simulations: [approvePermit2, approveUniversalRouter, swap],
+                estimate_gas: true,
+            };
+            const opts = {
+                headers: {
+                    'X-Access-Key': this.tenderlyAccessKey,
+                },
+                timeout: this.tenderlyRequestTimeout,
+            };
+            const url = TENDERLY_BATCH_SIMULATE_API(this.tenderlyBaseUrl, this.tenderlyUser, this.tenderlyProject);
+            metric.putMetric('TenderlySimulationUniversalRouterRequests', 1, MetricLoggerUnit.Count);
+            const before = Date.now();
+            if (Math.random() * 100 < ((_b = this.tenderlyNodeApiMigrationPercent) !== null && _b !== void 0 ? _b : 0) &&
+                ((_c = this.tenderlyNodeApiEnabledChains) !== null && _c !== void 0 ? _c : []).find((chainId) => chainId === this.chainId)) {
+                const { data: resp, status: httpStatus } = await this.requestNodeSimulation(approvePermit2, approveUniversalRouter, swap);
+                // We will maintain the original metrics TenderlySimulationUniversalRouterLatencies and TenderlySimulationUniversalRouterResponseStatus
+                // so that they don't provide the existing tenderly dashboard as well as simulation alerts
+                // In the meanwhile, we also add tenderly node metrics to distinguish from the tenderly api metrics
+                // Once we migrate to node endpoint 100%, original metrics TenderlySimulationUniversalRouterLatencies and TenderlySimulationUniversalRouterResponseStatus
+                // will work as is
+                metric.putMetric('TenderlySimulationUniversalRouterLatencies', Date.now() - before, MetricLoggerUnit.Milliseconds);
+                metric.putMetric('TenderlyNodeSimulationUniversalRouterLatencies', Date.now() - before, MetricLoggerUnit.Milliseconds);
+                metric.putMetric(`TenderlySimulationUniversalRouterResponseStatus${httpStatus}`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`TenderlyNodeSimulationUniversalRouterResponseStatus${httpStatus}`, 1, MetricLoggerUnit.Count);
+                // technically, we can also early return SimulationStatus.SystemDown when http status is not 200.
+                // in reality, when tenderly is down for whatever reason, i see it always throw during axios http request
+                // so that it hits the catch block in https://github.com/Uniswap/smart-order-router/blob/8bfec299001d3204483f761f57a38be04512a948/src/providers/tenderly-simulation-provider.ts#L226
+                // which is where we want to actually return SimulationStatus.SystemDown
+                // in other words, I've never see a TenderlySimulationUniversalRouterResponseStatus metric with a non-200 status
+                // if there's downtime, it won't log metric at https://github.com/Uniswap/smart-order-router/blob/8bfec299001d3204483f761f57a38be04512a948/src/providers/tenderly-simulation-provider.ts#L434
+                // Validate tenderly response body
+                if (!resp ||
+                    !resp.result ||
+                    resp.result.length < 3 ||
+                    resp.result[2].error) {
+                    log.error({ resp }, `Failed to invoke Tenderly Node Endpoint for gas estimation bundle ${JSON.stringify(body, null, 2)}.`);
+                    if (resp &&
+                        resp.result &&
+                        resp.result.length >= 3 &&
+                        resp.result[2].error &&
+                        resp.result[2].error.data) {
+                        return {
+                            ...swapRoute,
+                            simulationStatus: breakDownTenderlySimulationError(tokenIn, tokenOut, resp.result[2].error.data),
+                        };
+                    }
+                    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((Number(resp.result[2].gas) * estimateMultiplier).toFixed(0));
+                log.info({
+                    body,
+                    approvePermit2GasUsed: resp.result[0].gasUsed,
+                    approveUniversalRouterGasUsed: resp.result[1].gasUsed,
+                    swapGasUsed: resp.result[2].gasUsed,
+                    approvePermit2Gas: resp.result[0].gas,
+                    approveUniversalRouterGas: resp.result[1].gas,
+                    swapGas: resp.result[2].gas,
+                    swapWithMultiplier: estimatedGasUsed.toString(),
+                }, 'Successfully Simulated Approvals + Swap via Tenderly node endpoint for Universal Router. Gas used.');
+            }
+            else {
+                const resp = (await axios.post(url, body, opts)).data;
+                metric.putMetric('TenderlySimulationUniversalRouterLatencies', Date.now() - before, MetricLoggerUnit.Milliseconds);
+                metric.putMetric('TenderlyApiSimulationUniversalRouterLatencies', Date.now() - before, MetricLoggerUnit.Milliseconds);
+                // 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 * 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,
+                    approvePermit2Gas: resp.simulation_results[0].transaction.gas,
+                    approveUniversalRouterGas: resp.simulation_results[1].transaction.gas,
+                    swapGas: resp.simulation_results[2].transaction.gas,
+                    swapWithMultiplier: estimatedGasUsed.toString(),
+                }, 'Successfully Simulated Approvals + Swap via Tenderly Api endpoint for Universal Router. Gas used.');
+                log.info({
+                    body,
+                    swapSimulation: resp.simulation_results[2].simulation,
+                    swapTransaction: resp.simulation_results[2].transaction,
+                }, 'Successful Tenderly Api endpoint Swap Simulation for Universal Router');
+            }
+        }
+        else if (swapOptions.type == SwapType.SWAP_ROUTER_02) {
+            const approve = {
+                network_id: chainId,
+                input: APPROVE_TOKEN_FOR_TRANSFER,
+                estimate_gas: true,
+                to: tokenIn.address,
+                value: '0',
+                from: fromAddress,
+                simulation_type: TenderlySimulationType.QUICK,
+            };
+            const swap = {
+                network_id: chainId,
+                input: calldata,
+                to: SWAP_ROUTER_02_ADDRESSES(chainId),
+                estimate_gas: true,
+                value: currencyIn.isNative ? swapRoute.methodParameters.value : '0',
+                from: fromAddress,
+                block_number: blockNumber,
+                simulation_type: TenderlySimulationType.QUICK,
+            };
+            const body = { simulations: [approve, swap] };
+            const opts = {
+                headers: {
+                    'X-Access-Key': this.tenderlyAccessKey,
+                },
+                timeout: this.tenderlyRequestTimeout,
+            };
+            const url = TENDERLY_BATCH_SIMULATE_API(this.tenderlyBaseUrl, this.tenderlyUser, this.tenderlyProject);
+            metric.putMetric('TenderlySimulationSwapRouter02Requests', 1, MetricLoggerUnit.Count);
+            const before = Date.now();
+            const resp = (await axios.post(url, body, opts)).data;
+            const latencies = Date.now() - before;
+            log.info(`Tenderly simulation swap router02 request body: ${body}, having latencies ${latencies} in milliseconds.`);
+            metric.putMetric('TenderlySimulationSwapRouter02Latencies', latencies, MetricLoggerUnit.Milliseconds);
+            // 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 * estimateMultiplier).toFixed(0));
+            log.info({
+                body,
+                approveGasUsed: resp.simulation_results[0].transaction.gas_used,
+                swapGasUsed: resp.simulation_results[1].transaction.gas_used,
+                approveGas: resp.simulation_results[0].transaction.gas,
+                swapGas: resp.simulation_results[1].transaction.gas,
+                swapWithMultiplier: estimatedGasUsed.toString(),
+            }, 'Successfully Simulated Approval + Swap via Tenderly for SwapRouter02. Gas used.');
+            log.info({
+                body,
+                swapTransaction: resp.simulation_results[1].transaction,
+                swapSimulation: resp.simulation_results[1].simulation,
+            }, 'Successful Tenderly Swap Simulation for SwapRouter02');
+        }
+        else {
+            throw new Error(`Unsupported swap type: ${swapOptions}`);
+        }
+        const { estimatedGasUsedUSD, estimatedGasUsedQuoteToken, estimatedGasUsedGasToken, quoteGasAdjusted, } = await calculateGasUsed(chainId, swapRoute, estimatedGasUsed, this.v2PoolProvider, this.v3PoolProvider, this.provider, providerConfig);
+        logGasEstimationVsSimulationMetrics(swapRoute, estimatedGasUsed, chainId);
+        return {
+            ...initSwapRouteFromExisting(swapRoute, this.v2PoolProvider, this.v3PoolProvider, this.v4PoolProvider, this.portionProvider, quoteGasAdjusted, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, swapOptions, estimatedGasUsedGasToken, providerConfig),
+            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');
+    }
+    async requestNodeSimulation(approvePermit2, approveUniversalRouter, swap) {
+        const nodeEndpoint = TENDERLY_NODE_API(this.chainId, this.tenderlyNodeApiKey);
+        // TODO: ROUTE-362 - Revisit tenderly node simulation hardcode latest block number
+        // https://linear.app/uniswap/issue/ROUTE-362/revisit-tenderly-node-simulation-hardcode-latest-block-number
+        const blockNumber = // swap.block_number
+         
+        // ? BigNumber.from(swap.block_number).toHexString().replace('0x0', '0x')
+        'latest';
+        const body = {
+            id: 1,
+            jsonrpc: '2.0',
+            method: 'tenderly_estimateGasBundle',
+            params: [
+                [
+                    {
+                        from: approvePermit2.from,
+                        to: approvePermit2.to,
+                        data: approvePermit2.input,
+                    },
+                    {
+                        from: approveUniversalRouter.from,
+                        to: approveUniversalRouter.to,
+                        data: approveUniversalRouter.input,
+                    },
+                    { from: swap.from, to: swap.to, data: swap.input },
+                ],
+                blockNumber,
+            ],
+        };
+        const opts = {
+            timeout: this.tenderlyRequestTimeout,
+        };
+        const before = Date.now();
+        try {
+            // For now, we don't timeout tenderly node endpoint, but we should before we live switch to node endpoint
+            const { data: resp, status: httpStatus } = (await axios.post(nodeEndpoint, body, opts));
+            const latencies = Date.now() - before;
+            metric.putMetric('TenderlyNodeGasEstimateBundleLatencies', latencies, MetricLoggerUnit.Milliseconds);
+            metric.putMetric('TenderlyNodeGasEstimateBundleSuccess', 1, MetricLoggerUnit.Count);
+            if (httpStatus !== 200) {
+                log.error(`Failed to invoke Tenderly Node Endpoint for gas estimation bundle ${JSON.stringify(body, null, 2)}. HTTP Status: ${httpStatus}`, { resp });
+                return { data: resp.simulation_results[1], status: httpStatus };
+            }
+            return { data: resp.simulation_results[1], status: httpStatus };
+        }
+        catch (err) {
+            log.error({ err }, `Failed to invoke Tenderly Node Endpoint for gas estimation bundle ${JSON.stringify(body, null, 2)}. Error: ${err}`);
+            metric.putMetric('TenderlyNodeGasEstimateBundleFailure', 1, MetricLoggerUnit.Count);
+            // we will have to re-throw the error, so that simulation-provider can catch the error, and return simulation status = failed
+            throw err;
+        }
+    }
+}
+//# 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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"}

package/build/module/providers/token-fee-fetcher.d.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { BaseProvider } from '@ethersproject/providers';
+import { ChainId } from '@ring-protocol/sdk-core';
+import { ProviderConfig } from './provider';
+export declare const DEFAULT_TOKEN_FEE_RESULT: {
+    buyFeeBps: BigNumber;
+    sellFeeBps: BigNumber;
+};
+declare type Address = string;
+export declare type TokenFeeResult = {
+    buyFeeBps?: BigNumber;
+    sellFeeBps?: BigNumber;
+    feeTakenOnTransfer?: boolean;
+    externalTransferFailed?: boolean;
+    sellReverted?: boolean;
+};
+export declare type TokenFeeMap = Record<Address, TokenFeeResult>;
+export interface ITokenFeeFetcher {
+    fetchFees(addresses: Address[], providerConfig?: ProviderConfig): Promise<TokenFeeMap>;
+}
+export declare class OnChainTokenFeeFetcher implements ITokenFeeFetcher {
+    private chainId;
+    private tokenFeeAddress;
+    private gasLimitPerCall;
+    private amountToFlashBorrow;
+    private BASE_TOKEN;
+    private readonly contract;
+    constructor(chainId: ChainId, rpcProvider: BaseProvider, tokenFeeAddress?: string, gasLimitPerCall?: number, amountToFlashBorrow?: string);
+    fetchFees(addresses: Address[], providerConfig?: ProviderConfig): Promise<TokenFeeMap>;
+}
+export {};

package/build/module/providers/token-fee-fetcher.js

@@ -0,0 +1,110 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '@ring-protocol/sdk-core';
+import { TokenFeeDetector__factory } from '../types/other/factories/TokenFeeDetector__factory';
+import { log, metric, MetricLoggerUnit, WRAPPED_NATIVE_CURRENCY, } from '../util';
+const DEFAULT_TOKEN_BUY_FEE_BPS = BigNumber.from(0);
+const DEFAULT_TOKEN_SELL_FEE_BPS = BigNumber.from(0);
+// on detector failure, assume no fee
+export const DEFAULT_TOKEN_FEE_RESULT = {
+    buyFeeBps: DEFAULT_TOKEN_BUY_FEE_BPS,
+    sellFeeBps: DEFAULT_TOKEN_SELL_FEE_BPS,
+};
+// address at which the FeeDetector lens is deployed
+const FEE_DETECTOR_ADDRESS = (chainId) => {
+    switch (chainId) {
+        case ChainId.MAINNET:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.OPTIMISM:
+            return '0x95aDC98A949dCD94645A8cD56830D86e4Cf34Eff';
+        case ChainId.BNB:
+            return '0xCF6220e4496B091a6b391D48e770f1FbaC63E740';
+        case ChainId.POLYGON:
+            return '0xC988e19819a63C0e487c6Ad8d6668Ac773923BF2';
+        case ChainId.BASE:
+            return '0xCF6220e4496B091a6b391D48e770f1FbaC63E740';
+        case ChainId.ARBITRUM_ONE:
+            return '0x37324D81e318260DC4f0fCb68035028eFdE6F50e';
+        case ChainId.CELO:
+            return '0x8eEa35913DdeD795001562f9bA5b282d3ac04B60';
+        case ChainId.AVALANCHE:
+            return '0x8269d47c4910B8c87789aA0eC128C11A8614dfC8';
+        case ChainId.WORLDCHAIN:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.UNICHAIN_SEPOLIA:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.UNICHAIN:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.SONEIUM:
+            return '0x7A5299822b2cD9aC9A9f67756Aa2d62140e9A66f';
+        default:
+            // just default to mainnet contract
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+    }
+};
+// Amount has to be big enough to avoid rounding errors, but small enough that
+// most v2 pools will have at least this many token units
+// 100000 is the smallest number that avoids rounding errors in bps terms
+// 10000 was not sufficient due to rounding errors for rebase token (e.g. stETH)
+const AMOUNT_TO_FLASH_BORROW = '100000';
+// 1M gas limit per validate call, should cover most swap cases
+const GAS_LIMIT_PER_VALIDATE = 1000000;
+export class OnChainTokenFeeFetcher {
+    constructor(chainId, rpcProvider, tokenFeeAddress = FEE_DETECTOR_ADDRESS(chainId), gasLimitPerCall = GAS_LIMIT_PER_VALIDATE, amountToFlashBorrow = AMOUNT_TO_FLASH_BORROW) {
+        var _a;
+        this.chainId = chainId;
+        this.tokenFeeAddress = tokenFeeAddress;
+        this.gasLimitPerCall = gasLimitPerCall;
+        this.amountToFlashBorrow = amountToFlashBorrow;
+        this.BASE_TOKEN = (_a = WRAPPED_NATIVE_CURRENCY[this.chainId]) === null || _a === void 0 ? void 0 : _a.address;
+        this.contract = TokenFeeDetector__factory.connect(this.tokenFeeAddress, rpcProvider);
+    }
+    async fetchFees(addresses, providerConfig) {
+        const tokenToResult = {};
+        const addressesWithoutBaseToken = addresses.filter((address) => address.toLowerCase() !== this.BASE_TOKEN.toLowerCase());
+        const functionParams = addressesWithoutBaseToken.map((address) => [
+            address,
+            this.BASE_TOKEN,
+            this.amountToFlashBorrow,
+        ]);
+        const results = await Promise.all(functionParams.map(async ([address, baseToken, amountToBorrow]) => {
+            try {
+                // We use the validate function instead of batchValidate to avoid poison pill problem.
+                // One token that consumes too much gas could cause the entire batch to fail.
+                const feeResult = await this.contract.callStatic.validate(address, baseToken, amountToBorrow, {
+                    gasLimit: this.gasLimitPerCall,
+                    blockTag: providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber,
+                });
+                metric.putMetric('TokenFeeFetcherFetchFeesSuccess', 1, MetricLoggerUnit.Count);
+                return { address, ...feeResult };
+            }
+            catch (err) {
+                log.error({ err }, `Error calling validate on-chain for token ${address}`);
+                metric.putMetric('TokenFeeFetcherFetchFeesFailure', 1, MetricLoggerUnit.Count);
+                // in case of FOT token fee fetch failure, we return null
+                // so that they won't get returned from the token-fee-fetcher
+                // and thus no fee will be applied, and the cache won't cache on FOT tokens with failed fee fetching
+                return {
+                    address,
+                    buyFeeBps: undefined,
+                    sellFeeBps: undefined,
+                    feeTakenOnTransfer: false,
+                    externalTransferFailed: false,
+                    sellReverted: false,
+                };
+            }
+        }));
+        results.forEach(({ address, buyFeeBps, sellFeeBps, feeTakenOnTransfer, externalTransferFailed, sellReverted, }) => {
+            if (buyFeeBps || sellFeeBps) {
+                tokenToResult[address] = {
+                    buyFeeBps,
+                    sellFeeBps,
+                    feeTakenOnTransfer,
+                    externalTransferFailed,
+                    sellReverted,
+                };
+            }
+        });
+        return tokenToResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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