@guru-fund/sdk 0.1.0

package/dist/router/quoteWethTrade.d.ts

@@ -0,0 +1,14 @@
+import PoolHelper, { type FeeTier, type PoolRouteFinalizationContext } from './poolHelper';
+import type { Route } from './types';
+export interface QuoteWethTradeParams {
+    feeTier: FeeTier;
+    input: {
+        tokenIn: string;
+        tokenOut: string;
+        amountIn: bigint;
+        slippage: bigint;
+    };
+    poolHelper: PoolHelper;
+    finalization?: PoolRouteFinalizationContext;
+}
+export declare function quoteWethTrade({ feeTier, input, poolHelper, finalization, }: QuoteWethTradeParams): Promise<Route>;

package/dist/router/quoteWethTrade.js

@@ -0,0 +1,125 @@
+import { solidityPacked } from 'ethers';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { AerodromeV2Adapter__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, } from '../typechain/index.js';
+import { finalizeRouteQuote } from './finalizeRoute.js';
+export async function quoteWethTrade({ feeTier, input, poolHelper, finalization, }) {
+    const weth = poolHelper.addresses.tokens.WETH;
+    const wethIn = compareAddresses(input.tokenIn, weth);
+    const wethOut = compareAddresses(input.tokenOut, weth);
+    if (!wethIn && !wethOut) {
+        throw new Error('quoteWethTrade: path does not include WETH');
+    }
+    const quote = await poolHelper.getBestQuote({
+        tokenAmount: input.amountIn,
+        path: [input.tokenIn, input.tokenOut],
+        slippage: finalization ? 0n : input.slippage,
+    });
+    const adapter = poolHelper.getLotusAdapter(quote.exchangeFactory);
+    const dex = poolHelper.getDexData(quote.exchangeFactory);
+    const deadline = Math.floor((Date.now() + 1000 * 60) / 1000);
+    let buildSwap;
+    if (dex.type === 'v2') {
+        if (dex.kind === 'aerodrome') {
+            const routes = [
+                {
+                    from: input.tokenIn,
+                    to: input.tokenOut,
+                    stable: false,
+                    factory: quote.exchangeFactory,
+                },
+            ];
+            buildSwap = (amountToReceive) => {
+                const data = {
+                    amountToSend: input.amountIn,
+                    amountToReceive,
+                    routes,
+                    deadline,
+                };
+                return {
+                    data,
+                    callData: AerodromeV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                };
+            };
+        }
+        else {
+            buildSwap = (amountToReceive) => {
+                const data = {
+                    amountToSend: input.amountIn,
+                    amountToReceive,
+                    path: [input.tokenIn, input.tokenOut],
+                    deadline,
+                };
+                return {
+                    data,
+                    callData: UniswapV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                };
+            };
+        }
+    }
+    else {
+        const tier = quote.feeTier || feeTier;
+        const path = solidityPacked(['address', 'uint24', 'address'], [input.tokenIn, tier, input.tokenOut]);
+        buildSwap = (amountToReceive) => {
+            const data = {
+                amountToSend: input.amountIn,
+                amountToReceive,
+                path,
+                deadline,
+            };
+            return {
+                data,
+                callData: UniswapV3Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+            };
+        };
+    }
+    let finalized = {
+        ...buildSwap(quote.amount),
+        finalTollAmount: quote.swapFee,
+        effectiveSlippageBps: undefined,
+    };
+    if (finalization) {
+        const context = {
+            chainId: poolHelper.chainId,
+            blockNumber: finalization.blockNumber,
+            controller: finalization.controller,
+            vault: finalization.vault,
+            adapter,
+            account: finalization.account,
+            path: dex.type === 'v2'
+                ? [input.tokenIn, input.tokenOut]
+                : [
+                    {
+                        tokenIn: input.tokenIn,
+                        tokenOut: input.tokenOut,
+                        fee: String(quote.feeTier || feeTier),
+                    },
+                ],
+            buildCallDataForAmount: (amountToReceive) => String(buildSwap(amountToReceive).callData),
+            simulator: finalization.simulator,
+            prefixTxs: finalization.prefixTxs,
+        };
+        const result = await finalizeRouteQuote({
+            context,
+            amountToSend: input.amountIn,
+            amountQuoted: quote.amount,
+            initialTollAmount: wethIn ? quote.swapFee : 0n,
+            maxSlippageE3: finalization.maxSlippageE3 ?? input.slippage,
+        });
+        finalized = {
+            ...buildSwap(result.finalAmountToReceive),
+            finalTollAmount: result.finalTollAmount,
+            effectiveSlippageBps: result.effectiveSlippageBps,
+        };
+    }
+    return {
+        adapter,
+        data: finalized.data,
+        callData: finalized.callData,
+        toll: {
+            currency: weth,
+            amount: finalized.finalTollAmount,
+        },
+        hops: 1,
+        effectiveSlippageBps: finalized.effectiveSlippageBps,
+    };
+}

package/dist/router/simulation.d.ts

@@ -0,0 +1,43 @@
+import type { GuruProtocolChainId } from '../addresses';
+import type { V2Path, V3Path, V4Path } from './types';
+export interface PrefixTx {
+    from: string;
+    to: string;
+    callData: string;
+}
+export interface SimulateSwapParams {
+    chainId: GuruProtocolChainId;
+    from: string;
+    to: string;
+    callData: string;
+    blockNumber: number;
+    account: string;
+    amountIn: bigint;
+    tokenIn: string;
+    prefixTxs?: PrefixTx[];
+}
+export interface SimulateSwapResult {
+    success: boolean;
+    revertMessage?: string;
+}
+export type SwapSimulator = (params: SimulateSwapParams) => Promise<SimulateSwapResult>;
+export declare function encodeVaultExecute(adapter: string, swapCallData: string): string;
+export interface SwapSimulationContext {
+    chainId: GuruProtocolChainId;
+    blockNumber: number;
+    controller: string;
+    vault: string;
+    adapter: string;
+    account: string;
+    path: V3Path | V2Path | V4Path;
+    buildCallDataForAmount: (amountToReceive: bigint) => string;
+    simulator: SwapSimulator;
+    prefixTxs?: PrefixTx[];
+}
+export interface FindMaxAmountParams extends SwapSimulationContext {
+    amountQuoted: bigint;
+    amountWithSlippage: bigint;
+    amountIn: bigint;
+    maxSlippageE3?: bigint;
+}
+export declare function findMaxPassingAmountToReceive({ chainId, blockNumber, controller, vault, adapter, buildCallDataForAmount, amountQuoted, amountWithSlippage, path, account, amountIn, maxSlippageE3, simulator, prefixTxs, }: FindMaxAmountParams): Promise<bigint>;

package/dist/router/simulation.js

@@ -0,0 +1,70 @@
+import { FundVault__factory } from '../typechain/index.js';
+import { BUNDLE_SIMULATION_CANDIDATES, MAX_SLIPPAGE_SEARCH_E3, } from './constants.js';
+import { withSlippageTolerance } from './helpers.js';
+export function encodeVaultExecute(adapter, swapCallData) {
+    return FundVault__factory.createInterface().encodeFunctionData('execute', [
+        adapter,
+        swapCallData,
+    ]);
+}
+function generateCandidates(high, low, count) {
+    const totalRange = high - low;
+    const numberOfIntervals = BigInt(count - 1);
+    const candidates = [];
+    for (let i = 0; i < count; i++) {
+        const stepDown = (totalRange * BigInt(i)) / numberOfIntervals;
+        const candidate = high - stepDown;
+        candidates.push(candidate);
+    }
+    return candidates;
+}
+export async function findMaxPassingAmountToReceive({ chainId, blockNumber, controller, vault, adapter, buildCallDataForAmount, amountQuoted, amountWithSlippage, path, account, amountIn, maxSlippageE3, simulator, prefixTxs, }) {
+    const high = amountWithSlippage;
+    if (high <= 0n)
+        return amountWithSlippage;
+    const low = withSlippageTolerance(amountQuoted, MAX_SLIPPAGE_SEARCH_E3) || 1n;
+    const tokenIn = typeof path[0] === 'string' ? path[0] : path[0].tokenIn;
+    const simulate = (callData) => simulator({
+        chainId,
+        from: controller,
+        to: vault,
+        callData,
+        blockNumber,
+        account,
+        amountIn,
+        tokenIn,
+        prefixTxs,
+    });
+    if (low >= high) {
+        const { success } = await simulate(encodeVaultExecute(adapter, buildCallDataForAmount(high)));
+        return success ? high : amountWithSlippage;
+    }
+    const candidates = generateCandidates(high, low, BUNDLE_SIMULATION_CANDIDATES);
+    const results = await Promise.all(candidates.map((amount) => simulate(encodeVaultExecute(adapter, buildCallDataForAmount(amount)))));
+    const successIndices = results
+        .map((result, index) => (result.success ? index : -1))
+        .filter((index) => index !== -1);
+    if (successIndices.length === 0) {
+        if (maxSlippageE3) {
+            const fallback = withSlippageTolerance(amountQuoted, maxSlippageE3);
+            console.warn(`[findMax] All ${BUNDLE_SIMULATION_CANDIDATES} simulation candidates failed. ` +
+                `Falling back to caller-provided max slippage (${Number(maxSlippageE3) / 1000}%).`, { amountQuoted, fallback, maxSlippageE3 });
+            return fallback;
+        }
+        console.warn('Found no successful simulations with correct slippage, returning initial slippage', {
+            chainId,
+            blockNumber,
+            controller,
+            vault,
+            adapter,
+            amountQuoted,
+            amountWithSlippage,
+            callData: encodeVaultExecute(adapter, buildCallDataForAmount(high)),
+            path,
+        });
+        return amountWithSlippage;
+    }
+    const [bestIndex, secondBestIndex] = successIndices;
+    const targetIndex = secondBestIndex ?? bestIndex;
+    return candidates[targetIndex];
+}

package/dist/router/types.d.ts

@@ -0,0 +1,149 @@
+import type { SwapAeroV2Struct } from '../typechain/out/AerodromeV2Adapter';
+import type { SwapV2Struct } from '../typechain/out/UniswapV2Adapter';
+import type { SwapV3Struct } from '../typechain/out/UniswapV3Adapter';
+import type { SwapV4Struct } from '../typechain/out/UniswapV4Adapter';
+import type { GuruProtocolChainId } from '../addresses';
+import type { PrefixTx } from './simulation';
+export type V2Path = string[];
+export type V4PathHop = {
+    tokenIn: string;
+    tokenOut: string;
+    fee: number;
+    tickSpacing: number;
+    hooks: string;
+    hookData: string;
+};
+export type V4Path = V4PathHop[];
+export type V4HookPathKey = {
+    inputCurrency: string;
+    intermediateCurrency: string;
+    fee: number;
+    tickSpacing: number;
+    hook: string;
+    hookData: string;
+};
+export type SwapV4HookStruct = {
+    amountToSend: bigint;
+    amountToReceive: bigint;
+    currencyIn: string;
+    currencyOut: string;
+    path: V4HookPathKey[];
+    deadline: number;
+};
+export type V3PathHop = {
+    tokenIn: string;
+    tokenOut: string;
+    fee: string;
+};
+export type V3Path = V3PathHop[];
+export type CachedPath = {
+    type: 'v2';
+    path: V2Path;
+    hops: number;
+} | {
+    type: 'v3';
+    path: V3Path;
+    hops: number;
+} | {
+    type: 'v4';
+    path: V4Path;
+    hops: number;
+} | false;
+export interface RouteSearchParams {
+    chainId: GuruProtocolChainId;
+    tokenIn: string;
+    tokenInDecimals?: number;
+    tokenOut: string;
+    tokenOutDecimals?: number;
+    amountIn: bigint;
+    slippageE2?: number;
+    account: string;
+    vault: string;
+    prefixTxs?: PrefixTx[];
+}
+export interface Route {
+    adapter: string;
+    data: SwapV2Struct | SwapV3Struct | SwapAeroV2Struct | SwapV4Struct | SwapV4HookStruct;
+    callData: string | Uint8Array<ArrayBufferLike>;
+    toll: {
+        currency: string;
+        amount: bigint;
+    };
+    hops: number;
+    effectiveSlippageBps?: string;
+}
+export interface VeloraRouteResponse<TData = unknown> {
+    priceRoute: VeloraPriceRoute<TData>;
+}
+export interface VeloraPriceRoute<TData = unknown> {
+    blockNumber: number;
+    network: number;
+    srcToken: string;
+    srcDecimals: number;
+    srcAmount: string;
+    destToken: string;
+    destDecimals: number;
+    destAmount: string;
+    bestRoute: VeloraBestRoute<TData>[];
+    gasCostUSD: string;
+    gasCost: string;
+    side: string;
+    version: string;
+    contractAddress: string;
+    tokenTransferProxy: string;
+    contractMethod: string;
+}
+export interface VeloraBestRoute<TData = unknown> {
+    percent: number;
+    swaps: VeloraSwap<TData>[];
+}
+export interface VeloraSwap<TData = unknown> {
+    srcToken: string;
+    srcDecimals: number;
+    destToken: string;
+    destDecimals: number;
+    swapExchanges: VeloraSwapExchange<TData>[];
+}
+export interface VeloraSwapExchange<TData = unknown> {
+    exchange: string;
+    srcAmount: string;
+    destAmount: string;
+    percent: number;
+    poolAddresses: string[];
+    poolIdentifiers: string[];
+    data: TData;
+}
+export interface VeloraDataV2 {
+    router: string;
+    path: string[];
+    factory: string;
+    initCode: string;
+    feeFactor: number;
+    gasUSD: string;
+}
+export interface VeloraDataV3 {
+    path: V3PathHop[];
+    gasUSD: string;
+}
+export interface VeloraV4Hop {
+    pool: {
+        id: string;
+        key: {
+            currency0: string;
+            currency1: string;
+            fee: string;
+            tickSpacing: number;
+            hooks: string;
+        };
+    };
+    tokenIn: string;
+    tokenOut: string;
+    zeroForOne: boolean;
+}
+export interface VeloraDataV4 {
+    path: VeloraV4Hop[];
+    gasUSD?: string;
+}
+export type VeloraRouteResponseV2 = VeloraRouteResponse<VeloraDataV2>;
+export type VeloraRouteResponseV3 = VeloraRouteResponse<VeloraDataV3>;
+export type VeloraRouteResponseV4 = VeloraRouteResponse<VeloraDataV4>;

package/dist/router/types.js

@@ -0,0 +1 @@
+export {};

package/dist/router/v4PoolDiscovery.d.ts

@@ -0,0 +1,30 @@
+import { type Provider } from 'ethers';
+import { type GuruProtocolChainId } from '../addresses';
+import type { V4Path } from './types';
+export interface V4PoolKey {
+    currency0: string;
+    currency1: string;
+    fee: number;
+    tickSpacing: number;
+    hooks: string;
+}
+export declare function computeV4PoolId(key: V4PoolKey): string;
+interface DexscreenerPair {
+    dexId?: string;
+    labels?: string[];
+    pairAddress?: string;
+    baseToken?: {
+        address?: string;
+    };
+    quoteToken?: {
+        address?: string;
+    };
+    liquidity?: {
+        usd?: number;
+    };
+}
+export declare function selectV4PairPoolIds(pairs: DexscreenerPair[], tokenIn: string, tokenOut: string): string[];
+export declare function stitchNativeBridgeV4Paths(firstLegs: V4Path[], secondLegs: V4Path[]): V4Path[];
+export declare function discoverV4Paths(chainId: GuruProtocolChainId, tokenIn: string, tokenOut: string, provider: Provider, endpoint?: string): Promise<V4Path[]>;
+export declare function _clearV4DiscoveryCache(): void;
+export {};

package/dist/router/v4PoolDiscovery.js

@@ -0,0 +1,147 @@
+import { AbiCoder, keccak256 } from 'ethers';
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { DEXSCREENER_ENDPOINT, V4_ZERO_ADDRESS, V4_DISCOVERY_MAX_POOLS, V4_DISCOVERY_MIN_LIQUIDITY_USD, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, } from './constants.js';
+const V4_CHAIN_CONFIG = {
+    1: {
+        dexscreenerSlug: 'ethereum',
+        poolManager: '0x000000000004444c5dc75cb358380d2e3de08a90',
+        deployBlock: 21_600_000,
+    },
+    8453: {
+        dexscreenerSlug: 'base',
+        poolManager: '0x498581ff718922c3f8e6a244956af099b2652b2b',
+        deployBlock: 25_000_000,
+    },
+};
+const POOL_INITIALIZE_TOPIC = '0xdd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438';
+export function computeV4PoolId(key) {
+    return keccak256(AbiCoder.defaultAbiCoder().encode(['address', 'address', 'uint24', 'int24', 'address'], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
+}
+export function selectV4PairPoolIds(pairs, tokenIn, tokenOut) {
+    return pairs
+        .filter((pair) => {
+        const base = pair.baseToken?.address;
+        const quote = pair.quoteToken?.address;
+        if (!base || !quote || !pair.pairAddress)
+            return false;
+        const connects = (compareAddresses(base, tokenIn) &&
+            compareAddresses(quote, tokenOut)) ||
+            (compareAddresses(base, tokenOut) &&
+                compareAddresses(quote, tokenIn));
+        return (connects &&
+            pair.dexId === 'uniswap' &&
+            (pair.labels ?? []).includes('v4') &&
+            (pair.liquidity?.usd ?? 0) >= V4_DISCOVERY_MIN_LIQUIDITY_USD);
+    })
+        .sort((a, b) => (b.liquidity?.usd ?? 0) - (a.liquidity?.usd ?? 0))
+        .slice(0, V4_DISCOVERY_MAX_POOLS)
+        .map((pair) => pair.pairAddress.toLowerCase());
+}
+export function stitchNativeBridgeV4Paths(firstLegs, secondLegs) {
+    const paths = [];
+    for (const firstLeg of firstLegs) {
+        const firstHop = firstLeg.at(-1);
+        if (!firstHop || !compareAddresses(firstHop.tokenOut, V4_ZERO_ADDRESS)) {
+            continue;
+        }
+        for (const secondLeg of secondLegs) {
+            const secondHop = secondLeg[0];
+            if (!secondHop || !compareAddresses(secondHop.tokenIn, V4_ZERO_ADDRESS)) {
+                continue;
+            }
+            paths.push([...firstLeg, ...secondLeg]);
+            if (paths.length >= V4_DISCOVERY_MAX_POOLS)
+                return paths;
+        }
+    }
+    return paths;
+}
+const poolKeyCache = new Map();
+async function resolvePoolKey(chainId, poolId, provider) {
+    const cacheKey = `${chainId}:${poolId}`;
+    const cached = poolKeyCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const config = V4_CHAIN_CONFIG[chainId];
+    const logs = await provider.getLogs({
+        address: config.poolManager,
+        topics: [POOL_INITIALIZE_TOPIC, poolId],
+        fromBlock: config.deployBlock,
+        toBlock: 'latest',
+    });
+    const log = logs[0];
+    if (!log)
+        return null;
+    const [fee, tickSpacing, hooks] = AbiCoder.defaultAbiCoder().decode(['uint24', 'int24', 'address', 'uint160', 'int24'], log.data);
+    const key = {
+        currency0: '0x' + log.topics[2].slice(26),
+        currency1: '0x' + log.topics[3].slice(26),
+        fee: Number(fee),
+        tickSpacing: Number(tickSpacing),
+        hooks: String(hooks),
+    };
+    if (computeV4PoolId(key).toLowerCase() !== poolId.toLowerCase()) {
+        return null;
+    }
+    poolKeyCache.set(cacheKey, key);
+    return key;
+}
+const discoveryCache = new Map();
+export async function discoverV4Paths(chainId, tokenIn, tokenOut, provider, endpoint = DEXSCREENER_ENDPOINT) {
+    const cacheKey = `${chainId}:${tokenIn.toLowerCase()}:${tokenOut.toLowerCase()}`;
+    const cached = discoveryCache.get(cacheKey);
+    const ttl = cached?.paths.length
+        ? VELORA_PATH_CACHE_TTL
+        : VELORA_NEGATIVE_CACHE_TTL;
+    if (cached && Date.now() - cached.timestamp <= ttl)
+        return cached.paths;
+    let paths = await discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpoint, cached?.paths);
+    if (paths.length === 0 &&
+        !compareAddresses(tokenIn, V4_ZERO_ADDRESS) &&
+        !compareAddresses(tokenOut, V4_ZERO_ADDRESS)) {
+        const [firstLegs, secondLegs] = await Promise.all([
+            discoverDirectV4Paths(chainId, tokenIn, V4_ZERO_ADDRESS, provider, endpoint),
+            discoverDirectV4Paths(chainId, V4_ZERO_ADDRESS, tokenOut, provider, endpoint),
+        ]);
+        paths = stitchNativeBridgeV4Paths(firstLegs, secondLegs);
+    }
+    discoveryCache.set(cacheKey, { paths, timestamp: Date.now() });
+    return paths;
+}
+async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpoint, cachedPaths) {
+    const config = V4_CHAIN_CONFIG[chainId];
+    const { tokens } = getGuruProtocolAddresses(chainId);
+    const majors = [tokens.WETH, tokens.USDC, tokens.USDT, V4_ZERO_ADDRESS];
+    const isMajor = (token) => majors.some((major) => compareAddresses(major, token));
+    const queryOrder = isMajor(tokenIn) ? [tokenOut, tokenIn] : [tokenIn, tokenOut];
+    let poolIds = [];
+    for (const queryToken of queryOrder) {
+        const response = await fetch(`${endpoint}/${config.dexscreenerSlug}/${queryToken}`);
+        if (!response.ok) {
+            return cachedPaths ?? [];
+        }
+        const pairs = (await response.json());
+        poolIds = selectV4PairPoolIds(pairs, tokenIn, tokenOut);
+        if (poolIds.length > 0)
+            break;
+    }
+    const keys = await Promise.all(poolIds.map((poolId) => resolvePoolKey(chainId, poolId, provider)));
+    const paths = keys
+        .filter((key) => key !== null)
+        .map((key) => [
+        {
+            tokenIn,
+            tokenOut,
+            fee: key.fee,
+            tickSpacing: key.tickSpacing,
+            hooks: key.hooks,
+            hookData: '0x',
+        },
+    ]);
+    return paths;
+}
+export function _clearV4DiscoveryCache() {
+    discoveryCache.clear();
+    poolKeyCache.clear();
+}

package/dist/router/velora.d.ts

@@ -0,0 +1,42 @@
+import { type Provider } from 'ethers';
+import type { GuruProtocolAddresses, GuruProtocolChainId } from '../addresses';
+import { type SupportedDex } from './constants';
+import { type PrefixTx, type SwapSimulator } from './simulation';
+import type { CachedPath, Route } from './types';
+interface V2DexEntry {
+    adapter: string;
+    routerAddress: string;
+}
+interface V3DexEntry {
+    adapter: string;
+    quoterAddress: string;
+}
+interface VeloraDexConfig {
+    UniswapV2?: V2DexEntry;
+    PancakeSwapV2?: V2DexEntry;
+    UniswapV3?: V3DexEntry;
+    PancakeSwapV3?: V3DexEntry;
+    UniswapV4?: V3DexEntry;
+}
+export declare function buildVeloraDexConfig(addresses: GuruProtocolAddresses): VeloraDexConfig;
+export declare function isDexConfigured(addresses: GuruProtocolAddresses, dex: SupportedDex): boolean;
+export interface GetRouteFromPathParams {
+    chainId: GuruProtocolChainId;
+    addresses: GuruProtocolAddresses;
+    provider: Provider;
+    simulator: SwapSimulator;
+    dex: SupportedDex;
+    cachedPath: CachedPath;
+    amountIn: bigint;
+    toll: {
+        currency: string;
+        amount: bigint;
+    };
+    vault: string;
+    controller: string;
+    account: string;
+    maxSlippageE3?: bigint;
+    prefixTxs?: PrefixTx[];
+}
+export declare function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }: GetRouteFromPathParams): Promise<Route>;
+export {};