@kumbaya_xyz/smart-order-router 4.22.38

package/build/module/providers/subgraph-provider.d.ts

@@ -0,0 +1,56 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId, Currency, Token } from '@uniswap/sdk-core';
+import { SubgraphPool } from '../routers/alpha-router/functions/get-candidate-pools';
+import { ProviderConfig } from './provider';
+export interface ISubgraphProvider<TSubgraphPool extends SubgraphPool> {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+}
+export declare const PAGE_SIZE = 1000;
+export declare const BASE_V4_PAGE_SIZE = 3500;
+export type V3V4SubgraphPool = {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        id: string;
+    };
+    token1: {
+        id: string;
+    };
+    tvlETH: number;
+    tvlUSD: number;
+};
+export type V3V4RawSubgraphPool = {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        symbol: string;
+        id: string;
+    };
+    token1: {
+        symbol: string;
+        id: string;
+    };
+    totalValueLockedUSD: string;
+    totalValueLockedETH: string;
+    totalValueLockedUSDUntracked: string;
+};
+export declare abstract class SubgraphProvider<TRawSubgraphPool extends V3V4RawSubgraphPool, TSubgraphPool extends V3V4SubgraphPool> {
+    private protocol;
+    private chainId;
+    private retries;
+    private timeout;
+    private rollback;
+    private trackedEthThreshold;
+    private trackedZoraEthThreshold;
+    private zoraHooks;
+    private untrackedUsdThreshold;
+    private subgraphUrl?;
+    private bearerToken?;
+    private client;
+    constructor(protocol: Protocol, chainId: ChainId, retries: number, timeout: number, rollback: boolean, trackedEthThreshold: number, trackedZoraEthThreshold: number, zoraHooks: Set<string>, untrackedUsdThreshold?: number, subgraphUrl?: string | undefined, bearerToken?: string | undefined);
+    getPools(_currencyIn?: Currency, _currencyOut?: Currency, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+    protected abstract mapSubgraphPool(rawSubgraphPool: TRawSubgraphPool): TSubgraphPool;
+    protected getPoolFields(): string;
+}

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

@@ -0,0 +1,284 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId } from '@uniswap/sdk-core';
+import retry from 'async-retry';
+import Timeout from 'await-timeout';
+import { gql, GraphQLClient } from 'graphql-request';
+import _ from 'lodash';
+import { log, metric } from '../util';
+export const PAGE_SIZE = 1000; // 1k is max possible query size from subgraph.
+export const BASE_V4_PAGE_SIZE = 3500; // TheGraph v4 base max pagesize is 3600.
+export class SubgraphProvider {
+    constructor(protocol, chainId, retries = 2, timeout = 30000, rollback = true, trackedEthThreshold = 0.01, trackedZoraEthThreshold = 0.001, zoraHooks, 
+    // @ts-expect-error - kept for backward compatibility
+    untrackedUsdThreshold = Number.MAX_VALUE, subgraphUrl, bearerToken) {
+        this.protocol = protocol;
+        this.chainId = chainId;
+        this.retries = retries;
+        this.timeout = timeout;
+        this.rollback = rollback;
+        this.trackedEthThreshold = trackedEthThreshold;
+        this.trackedZoraEthThreshold = trackedZoraEthThreshold;
+        this.zoraHooks = zoraHooks;
+        this.untrackedUsdThreshold = untrackedUsdThreshold;
+        this.subgraphUrl = subgraphUrl;
+        this.bearerToken = bearerToken;
+        this.protocol = protocol;
+        if (!this.subgraphUrl) {
+            throw new Error(`No subgraph url for chain id: ${this.chainId}`);
+        }
+        if (this.bearerToken) {
+            this.client = new GraphQLClient(this.subgraphUrl, {
+                headers: {
+                    authorization: `Bearer ${this.bearerToken}`,
+                },
+            });
+        }
+        else {
+            this.client = new GraphQLClient(this.subgraphUrl);
+        }
+        if (protocol === Protocol.V4 && this.zoraHooks.size === 0) {
+            throw new Error('Zora hooks param is mandatory for V4');
+        }
+    }
+    async getPools(_currencyIn, _currencyOut, providerConfig) {
+        const beforeAll = Date.now();
+        let blockNumber = (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? await providerConfig.blockNumber
+            : undefined;
+        const pageSizeToUse = this.protocol === Protocol.V4 && this.chainId == ChainId.BASE
+            ? BASE_V4_PAGE_SIZE
+            : PAGE_SIZE;
+        log.info(`Getting ${this.protocol} pools from the subgraph with page size ${pageSizeToUse}${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? ` as of block ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}`
+            : ''}.`);
+        // Define separate queries for each filtering condition
+        const queries = [
+            // 1. Pools with high tracked ETH (for both V3 and V4)
+            {
+                name: 'High tracked ETH pools',
+                query: gql `
+          query getHighTrackedETHPools($pageSize: Int!, $id: String, $threshold: String!) {
+            pools(
+              first: $pageSize
+              ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+              where: {
+                id_gt: $id,
+                totalValueLockedETH_gt: $threshold
+              }
+            ) {
+              ${this.getPoolFields()}
+            }
+          }
+        `,
+                variables: { threshold: this.trackedEthThreshold.toString() },
+            },
+            // 2. V4: Non-Zora pools with liquidity > 0
+            ...(this.protocol === Protocol.V4
+                ? [
+                    {
+                        name: 'V4 non-Zora high liquidity pools',
+                        query: gql `
+          query getV4NonZoraHighLiquidityPools($pageSize: Int!, $id: String, $zoraHooks: [String!]!) {
+            pools(
+              first: $pageSize
+              ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+              where: {
+                id_gt: $id,
+                liquidity_gt: "0",
+                hooks_not_in: $zoraHooks
+              }
+            ) {
+              ${this.getPoolFields()}
+            }
+          }
+        `,
+                        variables: { zoraHooks: Array.from(this.zoraHooks) },
+                    },
+                    // 3. V4: Zora pools with liquidity > 0 AND TVL > trackedZoraEthThreshold
+                    {
+                        name: 'V4 Zora high liquidity pools',
+                        query: gql `
+          query getV4ZoraHighLiquidityPools($pageSize: Int!, $id: String, $zoraHooks: [String!]!, $zoraThreshold: String!) {
+            pools(
+              first: $pageSize
+              ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+              where: {
+                id_gt: $id,
+                liquidity_gt: "0",
+                hooks_in: $zoraHooks,
+                totalValueLockedETH_gt: $zoraThreshold
+              }
+            ) {
+              ${this.getPoolFields()}
+            }
+          }
+        `,
+                        variables: {
+                            zoraHooks: Array.from(this.zoraHooks),
+                            zoraThreshold: this.trackedZoraEthThreshold.toString(),
+                        },
+                    },
+                ]
+                : []),
+            // 4. V3: Pools with liquidity > 0 AND totalValueLockedETH = 0 (special V3 condition)
+            ...(this.protocol === Protocol.V3
+                ? [
+                    {
+                        name: 'V3 zero ETH pools',
+                        query: gql `
+          query getV3ZeroETHPools($pageSize: Int!, $id: String) {
+            pools(
+              first: $pageSize
+              ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+              where: {
+                id_gt: $id,
+                liquidity_gt: "0",
+                totalValueLockedETH: "0"
+              }
+            ) {
+              ${this.getPoolFields()}
+            }
+          }
+        `,
+                        variables: {},
+                    },
+                ]
+                : []),
+        ];
+        let allPools = [];
+        let retries = 0;
+        await retry(async () => {
+            const timeout = new Timeout();
+            const fetchPoolsForQuery = async (queryConfig) => {
+                let lastId = '';
+                let pools = [];
+                let poolsPage = [];
+                let totalPages = 0;
+                do {
+                    totalPages += 1;
+                    const start = Date.now();
+                    log.info(`Starting fetching for ${queryConfig.name} page ${totalPages} with page size ${pageSizeToUse}`);
+                    const poolsResult = await this.client.request(queryConfig.query, {
+                        pageSize: pageSizeToUse,
+                        id: lastId,
+                        ...queryConfig.variables,
+                    });
+                    poolsPage = poolsResult.pools;
+                    pools = pools.concat(poolsPage);
+                    if (pools.length > 0) {
+                        lastId = pools[pools.length - 1].id;
+                    }
+                    metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.${queryConfig.name
+                        .replace(/\s+/g, '_')
+                        .toLowerCase()}.paginate.pageSize`, poolsPage.length);
+                    log.info(`Fetched ${poolsPage.length} pools for ${queryConfig.name} in ${Date.now() - start}ms`);
+                } while (poolsPage.length > 0);
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.${queryConfig.name
+                    .replace(/\s+/g, '_')
+                    .toLowerCase()}.paginate`, totalPages);
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.${queryConfig.name
+                    .replace(/\s+/g, '_')
+                    .toLowerCase()}.pools.length`, pools.length);
+                return pools;
+            };
+            try {
+                // Fetch pools for each query in parallel
+                const poolPromises = queries.map((queryConfig) => fetchPoolsForQuery(queryConfig));
+                const allPoolsArrays = await Promise.all(poolPromises);
+                // Merge all results and deduplicate by pool ID
+                const poolMap = new Map();
+                allPoolsArrays.forEach((pools) => {
+                    pools.forEach((pool) => {
+                        poolMap.set(pool.id, pool);
+                    });
+                });
+                allPools = Array.from(poolMap.values());
+                const getPoolsPromise = Promise.resolve(allPools);
+                const timerPromise = timeout.set(this.timeout).then(() => {
+                    throw new Error(`Timed out getting pools from subgraph: ${this.timeout}`);
+                });
+                allPools = await Promise.race([getPoolsPromise, timerPromise]);
+                return;
+            }
+            catch (err) {
+                log.error({ err }, `Error fetching ${this.protocol} Subgraph Pools.`);
+                throw err;
+            }
+            finally {
+                timeout.clear();
+            }
+        }, {
+            retries: this.retries,
+            onRetry: (err, retry) => {
+                retries += 1;
+                if (this.rollback &&
+                    blockNumber &&
+                    _.includes(err.message, 'indexed up to')) {
+                    metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.indexError`, 1);
+                    blockNumber = blockNumber - 10;
+                    log.info(`Detected subgraph indexing error. Rolled back block number to: ${blockNumber}`);
+                }
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.timeout`, 1);
+                allPools = [];
+                log.info({ err }, `Failed to get pools from subgraph. Retry attempt: ${retry}`);
+            },
+        });
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.retries`, retries);
+        const beforeFilter = Date.now();
+        let poolsSanitized = [];
+        if (this.protocol === Protocol.V3) {
+            // Special treatment for all V3 pools in order to reduce latency due to thousands of pools with very low TVL locked
+            // - Include "parseFloat(pool.totalValueLockedETH) === 0" as in certain occasions we have no way of calculating derivedETH so this is 0
+            poolsSanitized = allPools
+                .filter((pool) => (parseInt(pool.liquidity) > 0 &&
+                parseFloat(pool.totalValueLockedETH) === 0) ||
+                parseFloat(pool.totalValueLockedETH) > this.trackedEthThreshold)
+                .map((pool) => {
+                return this.mapSubgraphPool(pool);
+            });
+        }
+        else if (this.protocol === Protocol.V4) {
+            // For V4, apply additional filtering as a safety measure even though queries are optimized
+            poolsSanitized = allPools
+                .filter((pool) => {
+                const liquidity = parseInt(pool.liquidity);
+                const tvl = parseFloat(pool.totalValueLockedETH);
+                const hooks = pool.hooks;
+                const isZora = this.zoraHooks.has(hooks);
+                if (isZora) {
+                    return tvl > this.trackedZoraEthThreshold;
+                }
+                return liquidity > 0 || tvl > this.trackedEthThreshold;
+            })
+                .map((pool) => {
+                return this.mapSubgraphPool(pool);
+            });
+        }
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.latency`, Date.now() - beforeFilter);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.length`, poolsSanitized.length);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.percent`, (poolsSanitized.length / allPools.length) * 100);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools`, 1);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.latency`, Date.now() - beforeAll);
+        log.info(`Got ${allPools.length} ${this.protocol} pools from the subgraph (after deduplication). ${poolsSanitized.length} after filtering`);
+        return poolsSanitized;
+    }
+    // Helper method to get the pool fields for GraphQL queries
+    getPoolFields() {
+        return `
+      id
+      token0 {
+        symbol
+        id
+      }
+      token1 {
+        symbol
+        id
+      }
+      feeTier
+      liquidity
+      totalValueLockedUSD
+      totalValueLockedETH
+    `;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subgraph-provider.js","sourceRoot":"","sources":["../../../src/providers/subgraph-provider.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,30 @@
+import { ApprovalTypes } from '@uniswap/router-sdk';
+import { ChainId, Currency, CurrencyAmount } from '@uniswap/sdk-core';
+import { IMulticallProvider } from './multicall-provider';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dhcC1yb3V0ZXItcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N3YXAtcm91dGVyLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxHQUFHLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxTQUFTLENBQUM7QUE2QnhELE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsWUFDWSxrQkFBc0MsRUFDdEMsT0FBZ0I7UUFEaEIsdUJBQWtCLEdBQWxCLGtCQUFrQixDQUFvQjtRQUN0QyxZQUFPLEdBQVAsT0FBTyxDQUFTO0lBQ3pCLENBQUM7SUFFRyxLQUFLLENBQUMsZUFBZSxDQUMxQixhQUF1QyxFQUN2QyxjQUF3Qzs7UUFFeEMsTUFBTSxjQUFjLEdBQXVCO1lBQ3pDO2dCQUNFLGFBQWEsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU87Z0JBQ3RDLGFBQWEsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFO2FBQ2xDO1lBQ0Q7Z0JBQ0UsY0FBYyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsT0FBTztnQkFDdkMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUU7YUFDbkM7U0FDRixDQUFDO1FBRUYsTUFBTSxFQUFFLEdBQ04sTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsNENBQTRDLENBR3hFO1lBQ0EsT0FBTyxFQUFFLHdCQUF3QixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7WUFDL0MsaUJBQWlCLEVBQUUscUJBQXFCLENBQUMsZUFBZSxFQUFFO1lBQzFELFlBQVksRUFBRSxpQkFBaUI7WUFDL0IsY0FBYztTQUNmLENBQUMsQ0FBQztRQUVMLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLEVBQUU7WUFDdEQsR0FBRyxDQUFDLElBQUksQ0FDTixFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQ3ZCLHdFQUF3RSxDQUN6RSxDQUFDO1lBQ0YsTUFBTSxJQUFJLEtBQUssQ0FDYix3RUFBd0UsQ0FDekUsQ0FBQztTQUNIO1FBRUQsTUFBTSxFQUFFLE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELE1BQU0sRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXBELE9BQU87WUFDTCxlQUFlLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztZQUNuQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7U0FDdEMsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,69 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId } from '@uniswap/sdk-core';
+import { GasModelProviderConfig, SwapOptions, SwapRoute } from '../routers';
+import { EthEstimateGasSimulator } from './eth-estimate-gas-provider';
+import { IPortionProvider } from './portion-provider';
+import { SimulationResult, Simulator } from './simulation-provider';
+import { IV2PoolProvider } from './v2/pool-provider';
+import { IV3PoolProvider } from './v3/pool-provider';
+import { IV4PoolProvider } from './v4/pool-provider';
+export type TenderlyResponseUniversalRouter = {
+    config: {
+        url: string;
+        method: string;
+        data: string;
+    };
+    simulation_results: [SimulationResult, SimulationResult, SimulationResult];
+};
+export type TenderlyResponseSwapRouter02 = {
+    config: {
+        url: string;
+        method: string;
+        data: string;
+    };
+    simulation_results: [SimulationResult, SimulationResult];
+};
+export type GasBody = {
+    gas: string;
+    gasUsed: string;
+};
+export type JsonRpcError = {
+    error: {
+        code: number;
+        message: string;
+        data: string;
+    };
+};
+export type TenderlyResponseEstimateGasBundle = {
+    id: number;
+    jsonrpc: string;
+    result: Array<JsonRpcError | GasBody>;
+};
+export declare const TENDERLY_NOT_SUPPORTED_CHAINS: ChainId[];
+export declare class FallbackTenderlySimulator extends Simulator {
+    private tenderlySimulator;
+    private ethEstimateGasSimulator;
+    constructor(chainId: ChainId, provider: JsonRpcProvider, portionProvider: IPortionProvider, tenderlySimulator: TenderlySimulator, ethEstimateGasSimulator: EthEstimateGasSimulator);
+    protected simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, providerConfig?: GasModelProviderConfig): Promise<SwapRoute>;
+}
+export declare class TenderlySimulator extends Simulator {
+    private tenderlyBaseUrl;
+    private tenderlyUser;
+    private tenderlyProject;
+    private tenderlyAccessKey;
+    private tenderlyNodeApiKey;
+    private v2PoolProvider;
+    private v3PoolProvider;
+    private v4PoolProvider;
+    private overrideEstimateMultiplier;
+    private tenderlyRequestTimeout?;
+    private tenderlyNodeApiMigrationPercent?;
+    private tenderlyNodeApiEnabledChains?;
+    private tenderlyServiceInstance;
+    constructor(chainId: ChainId, tenderlyBaseUrl: string, tenderlyUser: string, tenderlyProject: string, tenderlyAccessKey: string, tenderlyNodeApiKey: string, v2PoolProvider: IV2PoolProvider, v3PoolProvider: IV3PoolProvider, v4PoolProvider: IV4PoolProvider, provider: JsonRpcProvider, portionProvider: IPortionProvider, overrideEstimateMultiplier?: {
+        [chainId in ChainId]?: number;
+    }, tenderlyRequestTimeout?: number, tenderlyNodeApiMigrationPercent?: number, tenderlyNodeApiEnabledChains?: ChainId[]);
+    simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, providerConfig?: GasModelProviderConfig): Promise<SwapRoute>;
+    private logTenderlyErrorResponse;
+    private requestNodeSimulation;
+}