@guru-fund/sdk 0.1.0

package/dist/router/getUniswapV4Route.js

@@ -0,0 +1,324 @@
+import { Contract } from 'ethers';
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import { TOLL_DIVISOR_20BPS } from '../constants.js';
+import { FundVault__factory, UniswapV4Adapter__factory } from '../typechain/index.js';
+import { SWAP_DEADLINE_SECONDS, V4_ZERO_ADDRESS } from './constants.js';
+import { finalizeRouteQuote } from './finalizeRoute.js';
+import { resolveBaseToll } from './helpers.js';
+import { discoverV4Paths } from './v4PoolDiscovery.js';
+const V4_QUOTER_ABI = [
+    'function quoteExactInput((address exactCurrency, (address intermediateCurrency, uint24 fee, int24 tickSpacing, address hooks, bytes hookData)[] path, uint128 exactAmount) params) external returns (uint256 amountOut, uint256 gasEstimate)',
+];
+const V4_HOOK_ADAPTER_ABI = [
+    'function executeSwap((uint256 amountToSend,uint256 amountToReceive,address currencyIn,address currencyOut,(address inputCurrency,address intermediateCurrency,uint24 fee,int24 tickSpacing,address hook,bytes hookData)[] path,uint256 deadline) swap) returns ((address tokenIn,address tokenOut,uint256 amountIn,uint256 amountOut) trade)',
+];
+const V4_HOOK_LOCKED_SELECTOR = '0x0f2e5b6c';
+export function connectV4Quoter(address, provider) {
+    return new Contract(address, V4_QUOTER_ABI, provider);
+}
+export function toAdapterPathKeys(path) {
+    return path.map((hop) => ({
+        intermediateCurrency: hop.tokenOut,
+        fee: hop.fee,
+        tickSpacing: hop.tickSpacing,
+        hooks: hop.hooks,
+        hookData: hop.hookData,
+    }));
+}
+function isV4HookLockedError(reason) {
+    const seen = new Set();
+    const stack = [reason];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (typeof current === 'string' &&
+            current.toLowerCase().includes(V4_HOOK_LOCKED_SELECTOR)) {
+            return true;
+        }
+        if (typeof current !== 'object' || current === null)
+            continue;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        for (const key of Object.getOwnPropertyNames(current)) {
+            stack.push(current[key]);
+        }
+    }
+    return false;
+}
+export function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }) {
+    const toll = { ...baseToll };
+    let amountQuoted = quotedAmountToReceive;
+    let amountToSend = swapAmountIn;
+    let initialTollAmount = toll.amount;
+    if (toll.amount === 0n) {
+        if (quoteSource === 'quoter') {
+            toll.amount = quotedAmountToReceive / TOLL_DIVISOR_20BPS;
+            amountQuoted -= toll.amount;
+        }
+        initialTollAmount = 0n;
+    }
+    else {
+        amountToSend += toll.amount;
+    }
+    return { toll, amountQuoted, amountToSend, initialTollAmount };
+}
+async function previewV4AdapterOutput({ provider, controller, vault, adapter, tokenIn, amountToSend, path, deadline, }) {
+    const adapterIface = UniswapV4Adapter__factory.createInterface();
+    const vaultIface = FundVault__factory.createInterface();
+    const swapCallData = adapterIface.encodeFunctionData('executeSwap', [
+        {
+            amountToSend,
+            amountToReceive: 0n,
+            currencyIn: tokenIn,
+            path: toAdapterPathKeys(path),
+            deadline,
+        },
+    ]);
+    const vaultCallData = vaultIface.encodeFunctionData('execute', [
+        adapter,
+        swapCallData,
+    ]);
+    const encodedReturn = await provider.call({
+        from: controller,
+        to: vault,
+        data: vaultCallData,
+    });
+    const [adapterReturn] = vaultIface.decodeFunctionResult('execute', encodedReturn);
+    const [trade] = adapterIface.decodeFunctionResult('executeSwap', adapterReturn);
+    return BigInt(trade.amountOut);
+}
+export function toHookAdapterPathKeys(path) {
+    return path.map((hop) => ({
+        inputCurrency: hop.tokenIn,
+        intermediateCurrency: hop.tokenOut,
+        fee: hop.fee,
+        tickSpacing: hop.tickSpacing,
+        hook: hop.hooks,
+        hookData: hop.hookData,
+    }));
+}
+function resolveHookCurrencyOut(tokenOut, path) {
+    const lastHop = path[path.length - 1];
+    if (!lastHop)
+        return tokenOut;
+    return lastHop.tokenOut === V4_ZERO_ADDRESS ? tokenOut : lastHop.tokenOut;
+}
+function encodeV4HookAdapterSwap(swap) {
+    return new Contract(V4_ZERO_ADDRESS, V4_HOOK_ADAPTER_ABI).interface.encodeFunctionData('executeSwap', [swap]);
+}
+async function previewV4HookAdapterOutput({ provider, controller, vault, adapter, tokenIn, tokenOut, amountToSend, path, deadline, }) {
+    const hookAdapterIface = new Contract(V4_ZERO_ADDRESS, V4_HOOK_ADAPTER_ABI).interface;
+    const vaultIface = FundVault__factory.createInterface();
+    const swap = {
+        amountToSend,
+        amountToReceive: 0n,
+        currencyIn: tokenIn,
+        currencyOut: resolveHookCurrencyOut(tokenOut, path),
+        path: toHookAdapterPathKeys(path),
+        deadline,
+    };
+    const swapCallData = hookAdapterIface.encodeFunctionData('executeSwap', [
+        swap,
+    ]);
+    const vaultCallData = vaultIface.encodeFunctionData('execute', [
+        adapter,
+        swapCallData,
+    ]);
+    const encodedReturn = await provider.call({
+        from: controller,
+        to: vault,
+        data: vaultCallData,
+    });
+    const [adapterReturn] = vaultIface.decodeFunctionResult('execute', encodedReturn);
+    const [trade] = hookAdapterIface.decodeFunctionResult('executeSwap', adapterReturn);
+    return BigInt(trade.amountOut);
+}
+async function previewBestV4AdapterQuote(params) {
+    const previews = await Promise.allSettled(params.candidates.map((path) => previewV4AdapterOutput({ ...params, path })));
+    let best = null;
+    previews.forEach((result, i) => {
+        if (result.status !== 'fulfilled')
+            return;
+        const amountToReceive = result.value;
+        if (amountToReceive === 0n)
+            return;
+        if (!best || amountToReceive > best.amountToReceive) {
+            best = {
+                path: params.candidates[i],
+                amountToReceive,
+                source: 'adapter-preview',
+            };
+        }
+    });
+    return best;
+}
+async function previewBestV4HookAdapterQuote(params) {
+    const previews = await Promise.allSettled(params.candidates.map((path) => previewV4HookAdapterOutput({ ...params, path })));
+    let best = null;
+    let sawLockedHook = false;
+    let sawHookFailure = false;
+    previews.forEach((result, i) => {
+        if (result.status !== 'fulfilled') {
+            sawLockedHook ||= isV4HookLockedError(result.reason);
+            sawHookFailure ||= params.candidates[i].some((hop) => hop.hooks !== V4_ZERO_ADDRESS);
+            return;
+        }
+        const amountToReceive = result.value;
+        if (amountToReceive === 0n)
+            return;
+        if (!best || amountToReceive > best.amountToReceive) {
+            best = {
+                path: params.candidates[i],
+                amountToReceive,
+                source: 'adapter-preview',
+                adapter: params.adapter,
+            };
+        }
+    });
+    if (!best && sawLockedHook) {
+        throw new Error('TOKEN_LOCKED_BY_V4_HOOK');
+    }
+    if (!best && sawHookFailure) {
+        throw new Error('UNISWAP_V4_HOOK_ROUTE_REVERTED');
+    }
+    return best;
+}
+export default async function getUniswapV4Route(params, ctx) {
+    const { chainId, tokenIn, tokenOut, amountIn, slippageE2, vault, account, prefixTxs, } = params;
+    const { provider, simulator } = ctx;
+    const addresses = getGuruProtocolAddresses(chainId);
+    const adapter = addresses.adapters.uniswapV4;
+    const hookAdapter = addresses.adapters.uniswapV4Hook;
+    const quoterAddress = addresses.quoters.uniswapV4;
+    if (!adapter || !quoterAddress) {
+        throw new Error(`UniswapV4 not supported on chainId ${chainId}`);
+    }
+    const maxSlippageE3 = slippageE2 != null ? BigInt(slippageE2) * 10n : undefined;
+    const { baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
+    const candidates = await discoverV4Paths(chainId, tokenIn, tokenOut, provider);
+    if (candidates.length === 0) {
+        throw new Error('NO_UNISWAP_V4_ROUTES_FOUND');
+    }
+    const quoter = connectV4Quoter(quoterAddress, provider);
+    const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
+    const [quotes, blockNumber, controller] = await Promise.all([
+        Promise.allSettled(candidates.map((path) => quoter.quoteExactInput.staticCall({
+            exactCurrency: tokenIn,
+            path: toAdapterPathKeys(path),
+            exactAmount: swapAmountIn,
+        }))),
+        provider.getBlockNumber(),
+        FundVault__factory.connect(vault, provider).controller(),
+    ]);
+    let bestQuote = null;
+    quotes.forEach((result, i) => {
+        if (result.status !== 'fulfilled')
+            return;
+        const [amountOut] = result.value;
+        if (!bestQuote || amountOut > bestQuote.amountToReceive) {
+            bestQuote = {
+                path: candidates[i],
+                amountToReceive: amountOut,
+                source: 'quoter',
+            };
+        }
+    });
+    if (!bestQuote && !prefixTxs?.length) {
+        bestQuote = await previewBestV4AdapterQuote({
+            provider,
+            controller,
+            vault,
+            adapter,
+            tokenIn,
+            amountToSend: baseToll.amount === 0n ? swapAmountIn : amountIn,
+            deadline,
+            candidates,
+        });
+    }
+    if (!bestQuote && hookAdapter && !prefixTxs?.length) {
+        bestQuote = await previewBestV4HookAdapterQuote({
+            provider,
+            controller,
+            vault,
+            adapter: hookAdapter,
+            tokenIn,
+            tokenOut,
+            amountToSend: baseToll.amount === 0n ? swapAmountIn : amountIn,
+            deadline,
+            candidates,
+        });
+    }
+    if (!bestQuote || bestQuote.amountToReceive === 0n) {
+        throw new Error('NO_UNISWAP_V4_ROUTES_FOUND');
+    }
+    const selectedAdapter = bestQuote.adapter ?? adapter;
+    const bestPath = bestQuote.path;
+    const { toll, amountQuoted, amountToSend, initialTollAmount } = applyV4Toll({
+        baseToll,
+        quotedAmountToReceive: bestQuote.amountToReceive,
+        quoteSource: bestQuote.source,
+        swapAmountIn,
+    });
+    const pathKeys = toAdapterPathKeys(bestPath);
+    const hookPathKeys = toHookAdapterPathKeys(bestPath);
+    const buildCallDataForAmount = (amountToReceive) => selectedAdapter === hookAdapter
+        ? encodeV4HookAdapterSwap({
+            amountToSend,
+            amountToReceive,
+            currencyIn: tokenIn,
+            currencyOut: resolveHookCurrencyOut(tokenOut, bestPath),
+            path: hookPathKeys,
+            deadline,
+        })
+        : UniswapV4Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+            {
+                amountToSend,
+                amountToReceive,
+                currencyIn: tokenIn,
+                path: pathKeys,
+                deadline,
+            },
+        ]);
+    const context = {
+        chainId,
+        blockNumber,
+        controller,
+        vault,
+        adapter: selectedAdapter,
+        account,
+        path: bestPath,
+        buildCallDataForAmount,
+        simulator,
+        prefixTxs,
+    };
+    const { finalAmountToReceive, callData, effectiveSlippageBps, finalTollAmount, } = await finalizeRouteQuote({
+        context,
+        amountToSend,
+        amountQuoted,
+        initialTollAmount,
+        maxSlippageE3,
+    });
+    return {
+        adapter: selectedAdapter,
+        data: selectedAdapter === hookAdapter
+            ? {
+                amountToSend,
+                amountToReceive: finalAmountToReceive,
+                currencyIn: tokenIn,
+                currencyOut: resolveHookCurrencyOut(tokenOut, bestPath),
+                path: hookPathKeys,
+                deadline,
+            }
+            : {
+                amountToSend,
+                amountToReceive: finalAmountToReceive,
+                currencyIn: tokenIn,
+                path: pathKeys,
+                deadline,
+            },
+        callData,
+        toll: { ...toll, amount: finalTollAmount },
+        hops: bestPath.length,
+        effectiveSlippageBps,
+    };
+}

package/dist/router/getVeloraRoute.d.ts

@@ -0,0 +1,10 @@
+import type { Provider } from 'ethers';
+import type { PathFetcher } from './pathCache';
+import type { SwapSimulator } from './simulation';
+import type { Route, RouteSearchParams } from './types';
+export interface GetVeloraRouteContext {
+    provider: Provider;
+    simulator: SwapSimulator;
+    getPath: PathFetcher;
+}
+export default function getVeloraRoute(params: RouteSearchParams, ctx: GetVeloraRouteContext): Promise<Route>;

package/dist/router/getVeloraRoute.js

@@ -0,0 +1,68 @@
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import { Token } from '../helpers/Token.js';
+import { FundVault__factory } from '../typechain/index.js';
+import { MAX_ROUTE_HOPS, SUPPORTED_DEXS } from './constants.js';
+import { resolveBaseToll } from './helpers.js';
+import { getRouteFromPath, isDexConfigured } from './velora.js';
+async function fetchDecimals(token, provider) {
+    const { decimals } = await new Token(token, provider)
+        .metadata()
+        .catch(() => ({ decimals: 0 }));
+    return decimals;
+}
+export default async function getVeloraRoute(params, ctx) {
+    const { chainId, tokenIn, tokenInDecimals, tokenOut, tokenOutDecimals, amountIn, slippageE2, vault, account, prefixTxs, } = params;
+    const { provider, simulator, getPath } = ctx;
+    const addresses = getGuruProtocolAddresses(chainId);
+    const maxSlippageE3 = slippageE2 != null ? BigInt(slippageE2) * 10n : undefined;
+    const [srcDecimals, destDecimals, controller] = await Promise.all([
+        tokenInDecimals ?? fetchDecimals(tokenIn, provider),
+        tokenOutDecimals ?? fetchDecimals(tokenOut, provider),
+        FundVault__factory.connect(vault, provider).controller(),
+    ]);
+    const { baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
+    const routes = (await Promise.all(SUPPORTED_DEXS.map(async (dex) => {
+        try {
+            if (!isDexConfigured(addresses, dex))
+                return false;
+            const cachedPath = await getPath({
+                chainId,
+                dex,
+                tokenIn,
+                tokenOut,
+                srcDecimals: Number(srcDecimals),
+                destDecimals: Number(destDecimals),
+                vault,
+            });
+            if (!cachedPath)
+                return false;
+            if (cachedPath.hops > MAX_ROUTE_HOPS)
+                return false;
+            const toll = { ...baseToll };
+            return await getRouteFromPath({
+                chainId,
+                addresses,
+                provider,
+                simulator,
+                dex,
+                cachedPath,
+                amountIn: swapAmountIn,
+                toll,
+                vault,
+                controller,
+                account,
+                maxSlippageE3,
+                prefixTxs,
+            });
+        }
+        catch {
+            return false;
+        }
+    }))).filter((r) => !!r);
+    if (routes.length === 0) {
+        throw new Error('NO_VELORA_ROUTES_FOUND');
+    }
+    return routes.reduce((best, current) => BigInt(best.data.amountToReceive) < BigInt(current.data.amountToReceive)
+        ? current
+        : best);
+}

package/dist/router/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { GuruProtocolAddresses } from '../addresses';
+export declare function withSlippageTolerance(amount: bigint, slippage: bigint): bigint;
+export interface BaseTollContext {
+    tollIn: boolean;
+    baseToll: {
+        currency: string;
+        amount: bigint;
+    };
+    swapAmountIn: bigint;
+}
+export declare function resolveBaseToll(addresses: GuruProtocolAddresses, tokenIn: string, tokenOut: string, amountIn: bigint): BaseTollContext;

package/dist/router/helpers.js

@@ -0,0 +1,30 @@
+import { TOLL_DIVISOR_20BPS } from '../constants.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+const PERCENTAGE_DENOMINATOR = 100000n;
+export function withSlippageTolerance(amount, slippage) {
+    const tolerance = (amount * slippage) / PERCENTAGE_DENOMINATOR;
+    return amount - tolerance;
+}
+export function resolveBaseToll(addresses, tokenIn, tokenOut, amountIn) {
+    const tollableTokens = [
+        addresses.tokens.USDC.toLowerCase(),
+        addresses.tokens.USDT.toLowerCase(),
+        addresses.tokens.WETH.toLowerCase(),
+    ];
+    const tollIn = tollableTokens.some((token) => compareAddresses(token, tokenIn));
+    const tollOut = !tollIn &&
+        tollableTokens.some((token) => compareAddresses(token, tokenOut));
+    if (!tollIn && !tollOut) {
+        throw new Error('INVALID_SWAP');
+    }
+    let swapAmountIn = amountIn;
+    const baseToll = {
+        currency: tollIn ? tokenIn : tokenOut,
+        amount: 0n,
+    };
+    if (tollIn) {
+        baseToll.amount = amountIn / TOLL_DIVISOR_20BPS;
+        swapAmountIn = amountIn - baseToll.amount;
+    }
+    return { tollIn, baseToll, swapAmountIn };
+}

package/dist/router/index.d.ts

@@ -0,0 +1,22 @@
+import { type Provider } from 'ethers';
+import { type GuruProtocolChainId } from '../addresses';
+import type { PathFetcher } from './pathCache';
+import type { SwapSimulator } from './simulation';
+import type { Route, RouteSearchParams } from './types';
+export interface RouterContext {
+    provider: Provider;
+    simulator: SwapSimulator;
+    getSwapFeePercentage: () => Promise<bigint>;
+    getPath: PathFetcher;
+}
+export declare function veloraThenV4Discovery(velora: () => Promise<Route>, v4Discovery: () => Promise<Route>): Promise<Route>;
+export declare function tryWithVeloraFallback<T>(velora: () => Promise<T>, fallback: () => Promise<T>): Promise<T>;
+export declare function getRouteIn(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;
+export declare function getRouteOut(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;
+export declare function getPriceUsd1e18(token: string, ctx: {
+    chainId: GuruProtocolChainId;
+    provider: Provider;
+    getSwapFeePercentage: () => Promise<bigint>;
+}): Promise<bigint>;
+export type { Route, RouteSearchParams, V2Path, V3Path, V3PathHop, V4Path, V4PathHop, } from './types';
+export type { SwapSimulator, SimulateSwapParams, SimulateSwapResult, } from './simulation';

package/dist/router/index.js

@@ -0,0 +1,135 @@
+import { parseEther } from 'ethers';
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { Token } from '../helpers/Token.js';
+import { getFallbackRouteIn, getFallbackRouteOut, } from './getFallbackRoutes.js';
+import getUniswapV4Route, { connectV4Quoter, toAdapterPathKeys, } from './getUniswapV4Route.js';
+import getVeloraRoute from './getVeloraRoute.js';
+import PoolHelper from './poolHelper.js';
+import { discoverV4Paths } from './v4PoolDiscovery.js';
+export async function veloraThenV4Discovery(velora, v4Discovery) {
+    try {
+        return await velora();
+    }
+    catch {
+        return await v4Discovery();
+    }
+}
+export async function tryWithVeloraFallback(velora, fallback) {
+    try {
+        return await velora();
+    }
+    catch (err) {
+        if (err instanceof Error &&
+            (err.message.includes('TOKEN_LOCKED_BY_V4_HOOK') ||
+                err.message.includes('UNISWAP_V4_HOOK_ROUTE_REVERTED'))) {
+            throw err;
+        }
+        console.error('[@guru-fund/sdk] Velora route failed, retrying via fallback:', err);
+        return await fallback();
+    }
+}
+export async function getRouteIn(params, ctx) {
+    const veloraCtx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+        getPath: ctx.getPath,
+    };
+    const v4Ctx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+    };
+    const fallbackCtx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+        getSwapFeePercentage: ctx.getSwapFeePercentage,
+    };
+    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteIn(params, fallbackCtx));
+}
+export async function getRouteOut(params, ctx) {
+    const veloraCtx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+        getPath: ctx.getPath,
+    };
+    const v4Ctx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+    };
+    const fallbackCtx = {
+        provider: ctx.provider,
+        simulator: ctx.simulator,
+        getSwapFeePercentage: ctx.getSwapFeePercentage,
+    };
+    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteOut(params, fallbackCtx));
+}
+export async function getPriceUsd1e18(token, ctx) {
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const poolHelper = new PoolHelper({
+        chainId: ctx.chainId,
+        provider: ctx.provider,
+        getSwapFeePercentage: ctx.getSwapFeePercentage,
+    });
+    const { amount: wethUsdt } = await poolHelper.getBestQuote({
+        tokenAmount: parseEther('1'),
+        path: [addresses.tokens.WETH, addresses.tokens.USDT],
+        requireSwappable: false,
+    });
+    const wethUsd = wethUsdt * 10n ** 12n;
+    if (compareAddresses(token, addresses.tokens.WETH)) {
+        return wethUsd;
+    }
+    const { decimals } = await new Token(token, ctx.provider)
+        .metadata()
+        .catch(() => ({ decimals: 0 }));
+    const oneToken = 10n ** BigInt(decimals);
+    const WETH_UNIT = 10n ** 18n;
+    try {
+        const { amount: oneTokenInWeth } = await poolHelper.getBestQuote({
+            tokenAmount: oneToken,
+            path: [token, addresses.tokens.WETH],
+            requireSwappable: false,
+        });
+        return (oneTokenInWeth * wethUsd) / WETH_UNIT;
+    }
+    catch (error) {
+        const v4Usd = await _priceViaV4Pools(token, oneToken, wethUsd, ctx);
+        if (v4Usd !== null)
+            return v4Usd;
+        throw error;
+    }
+}
+async function _priceViaV4Pools(token, oneToken, wethUsd, ctx) {
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const quoterAddress = addresses.quoters.uniswapV4;
+    if (!quoterAddress)
+        return null;
+    const quoter = connectV4Quoter(quoterAddress, ctx.provider);
+    const WETH_UNIT = 10n ** 18n;
+    const quoteVia = async (counterpart) => {
+        const paths = await discoverV4Paths(ctx.chainId, token, counterpart, ctx.provider).catch(() => []);
+        const quotes = await Promise.allSettled(paths.map((path) => quoter.quoteExactInput.staticCall({
+            exactCurrency: token,
+            path: toAdapterPathKeys(path),
+            exactAmount: oneToken,
+        })));
+        let best = 0n;
+        for (const result of quotes) {
+            if (result.status !== 'fulfilled')
+                continue;
+            const [amountOut] = result.value;
+            if (amountOut > best)
+                best = amountOut;
+        }
+        return best > 0n ? best : null;
+    };
+    const inUsdc = await quoteVia(addresses.tokens.USDC);
+    if (inUsdc !== null) {
+        return inUsdc * 10n ** 12n;
+    }
+    const inWeth = await quoteVia(addresses.tokens.WETH);
+    if (inWeth !== null) {
+        return (inWeth * wethUsd) / WETH_UNIT;
+    }
+    return null;
+}

package/dist/router/pathCache.d.ts

@@ -0,0 +1,16 @@
+import { type SupportedDex } from './constants';
+import type { CachedPath, VeloraRouteResponse, VeloraRouteResponseV4 } from './types';
+export interface GetPathParams {
+    chainId: number;
+    dex: SupportedDex;
+    tokenIn: string;
+    tokenOut: string;
+    srcDecimals: number;
+    destDecimals: number;
+    vault: string;
+}
+export type PathFetcher = (params: GetPathParams) => Promise<CachedPath>;
+export declare function extractPathFromResponse(dex: SupportedDex, response: VeloraRouteResponse<unknown>): CachedPath;
+export declare function extractV4Path(response: VeloraRouteResponseV4): CachedPath;
+export declare function getPath({ chainId, dex, tokenIn, tokenOut, srcDecimals, destDecimals, vault, }: GetPathParams, endpoint?: string): Promise<CachedPath>;
+export declare function _clearPathCache(): void;