@guru-fund/sdk 0.1.0

package/dist/quotes/quoteRebalance.js

@@ -0,0 +1,201 @@
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import { MAX_BPS } from '../constants.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { Token } from '../helpers/Token.js';
+import FundDataFetcher, { WEIGHT_DENOMINATOR, } from '../helpers/FundDataFetcher.js';
+import ReceiptParser from '../helpers/ReceiptParser.js';
+import { getRouteIn, getRouteOut } from '../router/index.js';
+import { encodeVaultExecute } from '../router/simulation.js';
+import { quoteRebalanceSchema } from '../schemas/quoteRebalance.js';
+import { FundController__factory, FundLedger__factory, TradeController__factory, } from '../typechain/index.js';
+const TOLERANCE = 500n;
+const DUST_THRESHOLD = 5000000n;
+const NORMALIZER = BigInt(1e12);
+const absBigint = (v) => (v < 0n ? -v : v);
+export default async function quoteRebalance(params, ctx) {
+    const parsed = quoteRebalanceSchema.parse(params);
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const intermediary = addresses.tokens.USDC;
+    const provider = ctx.provider;
+    const ledger = FundLedger__factory.connect(parsed.ledger, provider);
+    const fetcher = new FundDataFetcher({
+        chainId: ctx.chainId,
+        provider,
+        getPriceUsd1e18: ctx.getPriceUsd1e18,
+    });
+    const [fundData, vault, manager, controllerAddress] = await Promise.all([
+        fetcher.fetchFundData(ledger),
+        ledger.vault(),
+        ledger.manager(),
+        ledger.controller(),
+    ]);
+    const targetWeightMap = new Map();
+    let totalTargetWeight = 0n;
+    for (const tw of parsed.targetWeights) {
+        const w = tw.weight;
+        targetWeightMap.set(tw.token.toLowerCase(), w);
+        totalTargetWeight += w;
+    }
+    if (totalTargetWeight !== WEIGHT_DENOMINATOR) {
+        throw new Error(`[@guru-fund/sdk] quoteRebalance: target weights must sum to ${WEIGHT_DENOMINATOR}, got ${totalTargetWeight}`);
+    }
+    const slippageByToken = new Map(Object.entries(parsed.slippageSettings ?? {}).map(([token, slippage]) => [token.toLowerCase(), slippage]));
+    const slippageE2For = (token) => {
+        const slippage = slippageByToken.get(token.toLowerCase());
+        return slippage == null ? undefined : Number(slippage / 10n);
+    };
+    const totalValue = fundData.totalValueLocked;
+    const sellAssets = [];
+    const buyAssets = [];
+    let skippedDust = 0;
+    for (const asset of fundData.assets) {
+        const targetWeight = targetWeightMap.get(asset.token.address.toLowerCase());
+        if (targetWeight === undefined)
+            continue;
+        const delta = targetWeight - asset.weight;
+        if (delta >= -TOLERANCE && delta <= TOLERANCE)
+            continue;
+        const deltaValueUsdt = (absBigint(delta) * totalValue) / WEIGHT_DENOMINATOR;
+        if (deltaValueUsdt < DUST_THRESHOLD) {
+            skippedDust++;
+            continue;
+        }
+        if (delta < 0n) {
+            const sellAmount = (absBigint(delta) * asset.balance) / asset.weight;
+            sellAssets.push({ asset, sellAmount });
+        }
+        else {
+            buyAssets.push({ asset, deltaWeight: delta });
+        }
+    }
+    const buildTxData = (extCalls) => ({
+        to: controllerAddress,
+        from: manager,
+        data: FundController__factory.createInterface().encodeFunctionData('executeTrades', [
+            parsed.ledger,
+            extCalls.map((c) => c.adapter),
+            extCalls.map((c) => c.callData),
+        ]),
+    });
+    const decodeLogs = (logs) => {
+        try {
+            const parser = ReceiptParser.fromSimulationLogs(logs);
+            const controller = TradeController__factory.connect(controllerAddress, provider);
+            const events = parser.getDecodedLogs(controller.interface, controller.getEvent('TradeExecuted'));
+            return {
+                trades: events.map((e) => ({
+                    tokenIn: e.trade.tokenIn,
+                    tokenOut: e.trade.tokenOut,
+                    amountIn: e.trade.amountIn,
+                    amountOut: e.trade.amountOut,
+                })),
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    if (sellAssets.length === 0 && buyAssets.length === 0) {
+        return {
+            extCalls: [],
+            trades: [],
+            cumulativeSlippageBps: 0n,
+            txData: buildTxData([]),
+            decodeLogs,
+            emptyReason: skippedDust > 0 ? 'dust' : 'balanced',
+        };
+    }
+    const extCalls = [];
+    const trades = [];
+    let totalUsd1e18In = 0n;
+    let totalUsd1e18Out = 0n;
+    const prefixTxs = [];
+    const pushPrefix = (route) => {
+        prefixTxs.push({
+            from: controllerAddress,
+            to: vault,
+            callData: encodeVaultExecute(String(route.adapter), String(route.callData)),
+        });
+    };
+    let totalIntermediaryProceeds = 0n;
+    for (const { asset, sellAmount } of sellAssets) {
+        if (compareAddresses(asset.token.address, intermediary)) {
+            totalIntermediaryProceeds += sellAmount;
+            continue;
+        }
+        const route = await getRouteOut({
+            chainId: ctx.chainId,
+            tokenIn: asset.token.address,
+            tokenOut: intermediary,
+            amountIn: sellAmount,
+            slippageE2: slippageE2For(asset.token.address),
+            account: vault,
+            vault,
+            prefixTxs: [...prefixTxs],
+        }, ctx);
+        const amountToReceive = BigInt(route.data.amountToReceive);
+        totalIntermediaryProceeds += amountToReceive;
+        extCalls.push({ adapter: route.adapter, callData: route.callData });
+        pushPrefix({
+            adapter: String(route.adapter),
+            callData: route.callData,
+        });
+        const usdIn1e18 = (sellAmount * asset.usd1e18Price) /
+            Token.unitFor(asset.token.decimals);
+        const usdOut1e18 = amountToReceive * NORMALIZER;
+        totalUsd1e18In += usdIn1e18;
+        totalUsd1e18Out += usdOut1e18;
+        trades.push({
+            tokenIn: asset.token.address,
+            tokenOut: intermediary,
+            amountIn: sellAmount,
+            expectedAmountOut: amountToReceive,
+        });
+    }
+    const totalBuyWeight = buyAssets.reduce((sum, b) => sum + b.deltaWeight, 0n);
+    for (const { asset, deltaWeight } of buyAssets) {
+        const buyAmountIntermediary = totalBuyWeight === 0n
+            ? 0n
+            : (totalIntermediaryProceeds * deltaWeight) / totalBuyWeight;
+        if (compareAddresses(asset.token.address, intermediary))
+            continue;
+        const route = await getRouteIn({
+            chainId: ctx.chainId,
+            tokenIn: intermediary,
+            tokenOut: asset.token.address,
+            amountIn: buyAmountIntermediary,
+            slippageE2: slippageE2For(asset.token.address),
+            account: vault,
+            vault,
+            prefixTxs: [...prefixTxs],
+        }, ctx);
+        const amountToReceive = BigInt(route.data.amountToReceive);
+        extCalls.push({ adapter: route.adapter, callData: route.callData });
+        pushPrefix({
+            adapter: String(route.adapter),
+            callData: route.callData,
+        });
+        const usdIn1e18 = buyAmountIntermediary * NORMALIZER;
+        const usdOut1e18 = (amountToReceive * asset.usd1e18Price) /
+            Token.unitFor(asset.token.decimals);
+        totalUsd1e18In += usdIn1e18;
+        totalUsd1e18Out += usdOut1e18;
+        trades.push({
+            tokenIn: intermediary,
+            tokenOut: asset.token.address,
+            amountIn: buyAmountIntermediary,
+            expectedAmountOut: amountToReceive,
+        });
+    }
+    const cumulativeSlippageBps = totalUsd1e18In > 0n
+        ? ((totalUsd1e18In - totalUsd1e18Out) * MAX_BPS) / totalUsd1e18In
+        : 0n;
+    return {
+        extCalls,
+        trades,
+        cumulativeSlippageBps,
+        txData: buildTxData(extCalls),
+        decodeLogs,
+        emptyReason: null,
+    };
+}

package/dist/quotes/quoteTrade.d.ts

@@ -0,0 +1,18 @@
+import type { TransactionRequest } from 'ethers';
+import { type GuruProtocolChainId } from '../addresses';
+import { type RouterContext } from '../router';
+import type { Route } from '../router/types';
+export interface QuoteTradeParams {
+    ledger: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    maxSlippage?: bigint;
+}
+export interface QuoteTradeContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+}
+export interface QuoteTradeResult extends Route {
+    txData: TransactionRequest;
+}
+export default function quoteTrade(params: QuoteTradeParams, ctx: QuoteTradeContext): Promise<QuoteTradeResult>;

package/dist/quotes/quoteTrade.js

@@ -0,0 +1,51 @@
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { getRouteIn, getRouteOut } from '../router/index.js';
+import { quoteTradeSchema } from '../schemas/quoteTrade.js';
+import buildTradeTx from '../txBuilders/buildTradeTx.js';
+import { FundLedger__factory, Protocol__factory } from '../typechain/index.js';
+export default async function quoteTrade(params, ctx) {
+    const parsed = quoteTradeSchema.parse(params);
+    const provider = ctx.provider;
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const protocol = Protocol__factory.connect(addresses.protocol, provider);
+    const isTollApplicable = async (token) => {
+        return (compareAddresses(token, addresses.tokens.WETH) ||
+            (await protocol.isEnabledStablecoin(token)));
+    };
+    const [tollIn, tollOut] = await Promise.all([
+        isTollApplicable(parsed.tokenIn),
+        isTollApplicable(parsed.tokenOut),
+    ]);
+    if (!tollIn && !tollOut) {
+        throw new Error(`[@guru-fund/sdk] quoteTrade: toll not applicable to ${parsed.tokenIn} ↔ ${parsed.tokenOut}`);
+    }
+    const getRoute = tollIn ? getRouteIn : getRouteOut;
+    const ledger = FundLedger__factory.connect(parsed.ledger, provider);
+    const [vaultAddress, controllerAddress, manager] = await Promise.all([
+        ledger.vault(),
+        ledger.controller(),
+        ledger.manager(),
+    ]);
+    const route = await getRoute({
+        chainId: ctx.chainId,
+        tokenIn: parsed.tokenIn,
+        tokenOut: parsed.tokenOut,
+        amountIn: parsed.amountIn,
+        slippageE2: parsed.maxSlippage != null
+            ? Number(parsed.maxSlippage / 10n)
+            : undefined,
+        account: vaultAddress,
+        vault: vaultAddress,
+    }, ctx);
+    return {
+        ...route,
+        txData: buildTradeTx({
+            controller: controllerAddress,
+            ledger: parsed.ledger,
+            adapter: String(route.adapter),
+            callData: String(route.callData),
+            from: manager,
+        }),
+    };
+}

package/dist/quotes/quoteWithdrawal.d.ts

@@ -0,0 +1,41 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+import type { GuruProtocolChainId } from '../addresses';
+import { type GetPriceUsd1e18 } from '../helpers/FundDataFetcher';
+import { type RouterContext } from '../router';
+import type { Route } from '../router/types';
+export type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface QuoteWithdrawalParams {
+    ledger: string;
+    account: string;
+    shares: bigint;
+    coin: string;
+    referrerFeeBps: bigint;
+    slippageSettings?: Record<string, string | number | bigint>;
+}
+export interface QuoteWithdrawalContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+    getPriceUsd1e18: GetPriceUsd1e18;
+}
+export interface QuoteWithdrawalLogs {
+    netAmountOut: bigint;
+    managerFee: bigint;
+}
+export type SimulationLog = {
+    address: string;
+    data: string;
+    topics: string[];
+};
+export interface QuoteWithdrawalResult {
+    proceeds: bigint;
+    extCalls: ExternalCallStruct[];
+    routing: Route['data'][];
+    referrerFeeBps: bigint;
+    cumulativeSlippageBps: bigint;
+    perAssetSlippageBps: Record<string, bigint>;
+    txData: TransactionRequest;
+    decodeLogs: (logs: SimulationLog[]) => QuoteWithdrawalLogs | null;
+}
+export default function quoteWithdrawal(params: QuoteWithdrawalParams, ctx: QuoteWithdrawalContext): Promise<QuoteWithdrawalResult>;

package/dist/quotes/quoteWithdrawal.js

@@ -0,0 +1,113 @@
+import { MAX_BPS, SECONDS_PER_YEAR } from '../constants.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { Token } from '../helpers/Token.js';
+import FundDataFetcher, { WEIGHT_DENOMINATOR, } from '../helpers/FundDataFetcher.js';
+import ReceiptParser from '../helpers/ReceiptParser.js';
+import { getRouteOut } from '../router/index.js';
+import { quoteWithdrawalSchema } from '../schemas/quoteWithdrawal.js';
+import buildWithdrawTx from '../txBuilders/buildWithdrawTx.js';
+import { FundLedger__factory } from '../typechain/index.js';
+const MANAGEMENT_FEE_BPS = 200n;
+const MANAGEMENT_FEE_HORIZON_SECONDS = 300n;
+const slippageE2For = (settings, token) => {
+    const slippage = settings?.[token.toLowerCase()];
+    return slippage == null ? undefined : Number(BigInt(slippage) / 10n);
+};
+export default async function quoteWithdrawal(params, ctx) {
+    const parsed = quoteWithdrawalSchema.parse(params);
+    if (parsed.referrerFeeBps < 0n || parsed.referrerFeeBps > MAX_BPS) {
+        throw new Error(`referrerFeeBps must be between 0 and ${MAX_BPS}, got ${parsed.referrerFeeBps}`);
+    }
+    const provider = ctx.provider;
+    const ledger = FundLedger__factory.connect(parsed.ledger, provider);
+    const fetcher = new FundDataFetcher({
+        chainId: ctx.chainId,
+        provider,
+        getPriceUsd1e18: ctx.getPriceUsd1e18,
+    });
+    const [fundData, vault, controllerAddress, viewBalance, rawBalance, rawTotalSupply, totalSupplyOffset,] = await Promise.all([
+        fetcher.fetchFundData(ledger),
+        ledger.vault(),
+        ledger.controller(),
+        ledger.balanceOf(parsed.account),
+        ledger.preAdjustedBalanceOf(parsed.account),
+        ledger.rawTotalSupply(),
+        ledger.totalSupplyOffset(),
+    ]);
+    const stablecoinBalance = await new Token(parsed.coin, provider).balanceOf(vault);
+    const pendingMgmtFees = fundData.tokenTotalSupply - rawTotalSupply - totalSupplyOffset;
+    const checkpointDelta = viewBalance - rawBalance;
+    const effectiveSupply = rawTotalSupply + pendingMgmtFees + checkpointDelta;
+    let proceeds = (parsed.shares * stablecoinBalance) / effectiveSupply;
+    const routing = [];
+    const extCalls = [];
+    const assetsToSwap = fundData.assets.filter((asset) => !compareAddresses(asset.token.address, parsed.coin));
+    const routeResults = await Promise.all(assetsToSwap.map(async (asset) => {
+        const amountIn = (parsed.shares * asset.balance) / effectiveSupply;
+        const mgmtFeeBuffer = (amountIn *
+            MANAGEMENT_FEE_BPS *
+            MANAGEMENT_FEE_HORIZON_SECONDS) /
+            (MAX_BPS * SECONDS_PER_YEAR);
+        const route = await getRouteOut({
+            chainId: ctx.chainId,
+            tokenIn: asset.token.address,
+            tokenOut: parsed.coin,
+            amountIn: amountIn - mgmtFeeBuffer,
+            slippageE2: slippageE2For(parsed.slippageSettings, asset.token.address),
+            account: parsed.account,
+            vault,
+        }, ctx);
+        return { asset, route };
+    }));
+    const perAssetSlippageBps = {};
+    let cumulativeSlippageBps = 0n;
+    for (const { asset, route } of routeResults) {
+        routing.push(route.data);
+        extCalls.push({
+            adapter: route.adapter,
+            callData: route.callData,
+        });
+        proceeds += BigInt(route.data.amountToReceive);
+        const bps = route.effectiveSlippageBps;
+        if (bps != null) {
+            const bpsN = BigInt(bps);
+            const assetKey = asset.token.address.toLowerCase();
+            perAssetSlippageBps[assetKey] = bpsN;
+            cumulativeSlippageBps += (bpsN * asset.weight) / WEIGHT_DENOMINATOR;
+        }
+    }
+    const referrerFeeBps = parsed.referrerFeeBps;
+    const txData = buildWithdrawTx({
+        controller: controllerAddress,
+        ledger: parsed.ledger,
+        coin: parsed.coin,
+        shares: parsed.shares,
+        extCalls,
+        referrerFeeBps,
+        from: parsed.account,
+    });
+    const withdrawnEvent = ledger.getEvent('Withdrawn');
+    const decodeLogs = (logs) => {
+        try {
+            const parser = ReceiptParser.fromSimulationLogs(logs);
+            const withdrawn = parser.getDecodedLog(ledger.interface, withdrawnEvent);
+            return {
+                netAmountOut: withdrawn.netAmountOut,
+                managerFee: withdrawn.managerFee,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        proceeds,
+        extCalls,
+        routing,
+        referrerFeeBps,
+        cumulativeSlippageBps,
+        perAssetSlippageBps,
+        txData,
+        decodeLogs,
+    };
+}

package/dist/router/constants.d.ts

@@ -0,0 +1,18 @@
+export declare const VELORA_ENDPOINT = "https://api.velora.xyz/swap";
+export declare const SUPPORTED_DEXS: readonly ["UniswapV2", "UniswapV3", "UniswapV4", "PancakeSwapV2", "PancakeSwapV3"];
+export declare const VELORA_VERSION_BY_DEX: Partial<Record<SupportedDex, string>>;
+export type SupportedDex = (typeof SUPPORTED_DEXS)[number];
+export declare const INITIAL_SLIPPAGE_E3 = 500n;
+export declare const MAX_EFFECTIVE_SLIPPAGE_BPS = 8000n;
+export declare const SWAP_DEADLINE_SECONDS = 1800;
+export declare const MAX_ROUTE_HOPS = 3;
+export declare const RATE_LIMIT_MAX_RETRIES = 16;
+export declare const SIMULATION_RETRY_BASE_DELAY_MS = 500;
+export declare const BUNDLE_SIMULATION_CANDIDATES = 20;
+export declare const MAX_SLIPPAGE_SEARCH_E3 = 8000n;
+export declare const VELORA_PATH_CACHE_TTL: number;
+export declare const VELORA_NEGATIVE_CACHE_TTL: number;
+export declare const V4_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DEXSCREENER_ENDPOINT = "https://api.dexscreener.com/token-pairs/v1";
+export declare const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10000;
+export declare const V4_DISCOVERY_MAX_POOLS = 3;

package/dist/router/constants.js

@@ -0,0 +1,25 @@
+export const VELORA_ENDPOINT = 'https://api.velora.xyz/swap';
+export const SUPPORTED_DEXS = [
+    'UniswapV2',
+    'UniswapV3',
+    'UniswapV4',
+    'PancakeSwapV2',
+    'PancakeSwapV3',
+];
+export const VELORA_VERSION_BY_DEX = {
+    UniswapV4: '6.2',
+};
+export const INITIAL_SLIPPAGE_E3 = 500n;
+export const MAX_EFFECTIVE_SLIPPAGE_BPS = 8000n;
+export const SWAP_DEADLINE_SECONDS = 1800;
+export const MAX_ROUTE_HOPS = 3;
+export const RATE_LIMIT_MAX_RETRIES = 16;
+export const SIMULATION_RETRY_BASE_DELAY_MS = 500;
+export const BUNDLE_SIMULATION_CANDIDATES = 20;
+export const MAX_SLIPPAGE_SEARCH_E3 = 8000n;
+export const VELORA_PATH_CACHE_TTL = 1000 * 60 * 60;
+export const VELORA_NEGATIVE_CACHE_TTL = 1000 * 60;
+export const V4_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const DEXSCREENER_ENDPOINT = 'https://api.dexscreener.com/token-pairs/v1';
+export const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10_000;
+export const V4_DISCOVERY_MAX_POOLS = 3;

package/dist/router/finalizeRoute.d.ts

@@ -0,0 +1,16 @@
+import { type SwapSimulationContext } from './simulation';
+export interface FinalizeRouteQuoteParams {
+    context: SwapSimulationContext;
+    amountToSend: bigint;
+    amountQuoted: bigint;
+    initialTollAmount: bigint;
+    outputTollE3?: bigint;
+    maxSlippageE3?: bigint;
+}
+export interface FinalizeRouteQuoteResult {
+    finalAmountToReceive: bigint;
+    callData: string;
+    effectiveSlippageBps: string;
+    finalTollAmount: bigint;
+}
+export declare function finalizeRouteQuote({ context, amountToSend, amountQuoted, initialTollAmount, outputTollE3, maxSlippageE3, }: FinalizeRouteQuoteParams): Promise<FinalizeRouteQuoteResult>;

package/dist/router/finalizeRoute.js

@@ -0,0 +1,29 @@
+import { INITIAL_SLIPPAGE_E3, MAX_EFFECTIVE_SLIPPAGE_BPS } from './constants.js';
+import { withSlippageTolerance } from './helpers.js';
+import { findMaxPassingAmountToReceive, } from './simulation.js';
+export async function finalizeRouteQuote({ context, amountToSend, amountQuoted, initialTollAmount, outputTollE3 = 200n, maxSlippageE3, }) {
+    const amountWithSlippage = withSlippageTolerance(amountQuoted, INITIAL_SLIPPAGE_E3);
+    const finalAmountToReceive = await findMaxPassingAmountToReceive({
+        ...context,
+        amountQuoted,
+        amountWithSlippage,
+        amountIn: amountToSend,
+        maxSlippageE3,
+    });
+    const finalTollAmount = initialTollAmount === 0n
+        ? (finalAmountToReceive * outputTollE3) / 100000n
+        : initialTollAmount;
+    const rawBps = finalAmountToReceive > 0n
+        ? ((amountQuoted - finalAmountToReceive) * 10000n) /
+            finalAmountToReceive
+        : 0n;
+    const effectiveSlippageBps = (rawBps > MAX_EFFECTIVE_SLIPPAGE_BPS
+        ? MAX_EFFECTIVE_SLIPPAGE_BPS
+        : rawBps).toString();
+    return {
+        finalAmountToReceive,
+        callData: context.buildCallDataForAmount(finalAmountToReceive),
+        effectiveSlippageBps,
+        finalTollAmount,
+    };
+}

package/dist/router/getFallbackRoutes.d.ts

@@ -0,0 +1,10 @@
+import type { Provider } from 'ethers';
+import type { SwapSimulator } from './simulation';
+import type { Route, RouteSearchParams } from './types';
+export interface GetFallbackRouteContext {
+    provider: Provider;
+    simulator: SwapSimulator;
+    getSwapFeePercentage: () => Promise<bigint>;
+}
+export declare function getFallbackRouteIn(params: RouteSearchParams, ctx: GetFallbackRouteContext): Promise<Route>;
+export declare function getFallbackRouteOut(params: RouteSearchParams, ctx: GetFallbackRouteContext): Promise<Route>;

package/dist/router/getFallbackRoutes.js

@@ -0,0 +1,91 @@
+import compareAddresses from '../helpers/compareAddresses.js';
+import { FundVault__factory } from '../typechain/index.js';
+import PoolHelper from './poolHelper.js';
+import { quoteWethTrade } from './quoteWethTrade.js';
+export async function getFallbackRouteIn(params, ctx) {
+    const { chainId, tokenIn, tokenOut, amountIn, slippageE2 } = params;
+    const slippage = BigInt(slippageE2 ?? 500) * 10n;
+    const poolHelper = new PoolHelper({
+        chainId,
+        provider: ctx.provider,
+        getSwapFeePercentage: ctx.getSwapFeePercentage,
+    });
+    const weth = poolHelper.addresses.tokens.WETH;
+    const [controller, blockNumber] = await Promise.all([
+        FundVault__factory.connect(params.vault, ctx.provider).controller(),
+        ctx.provider.getBlockNumber(),
+    ]);
+    const finalization = {
+        blockNumber,
+        controller,
+        vault: params.vault,
+        account: params.account,
+        simulator: ctx.simulator,
+        prefixTxs: params.prefixTxs,
+        maxSlippageE3: slippage,
+    };
+    if (compareAddresses(tokenIn, weth) || compareAddresses(tokenOut, weth)) {
+        const pairedToken = compareAddresses(tokenIn, weth) ? tokenOut : tokenIn;
+        const coinTokenPool = await poolHelper.getUniswapCompatibleTokenPool(pairedToken);
+        return quoteWethTrade({
+            feeTier: coinTokenPool.feeTier,
+            input: { tokenIn, tokenOut, amountIn, slippage },
+            poolHelper,
+            finalization,
+        });
+    }
+    const pool = await poolHelper.getUniswapCompatibleTokenPool(tokenOut);
+    const path = [tokenIn, weth, tokenOut];
+    const route = await poolHelper.getStableForTokenQuote({
+        path,
+        inputAmount: amountIn,
+        slippage,
+        exchangeFactory: pool.exchangeFactory,
+        finalization,
+    });
+    return { ...route, hops: 2 };
+}
+export async function getFallbackRouteOut(params, ctx) {
+    const { chainId, tokenIn, tokenOut, amountIn, slippageE2 } = params;
+    const slippage = BigInt(slippageE2 ?? 500) * 10n;
+    const poolHelper = new PoolHelper({
+        chainId,
+        provider: ctx.provider,
+        getSwapFeePercentage: ctx.getSwapFeePercentage,
+    });
+    const weth = poolHelper.addresses.tokens.WETH;
+    const [controller, blockNumber] = await Promise.all([
+        FundVault__factory.connect(params.vault, ctx.provider).controller(),
+        ctx.provider.getBlockNumber(),
+    ]);
+    const finalization = {
+        blockNumber,
+        controller,
+        vault: params.vault,
+        account: params.account,
+        simulator: ctx.simulator,
+        prefixTxs: params.prefixTxs,
+        maxSlippageE3: slippage,
+    };
+    if (compareAddresses(tokenIn, weth) || compareAddresses(tokenOut, weth)) {
+        const pairedToken = compareAddresses(tokenIn, weth) ? tokenOut : tokenIn;
+        const coinTokenPool = await poolHelper.getUniswapCompatibleTokenPool(pairedToken);
+        const route = await quoteWethTrade({
+            feeTier: coinTokenPool.feeTier,
+            input: { tokenIn, tokenOut, amountIn, slippage },
+            poolHelper,
+            finalization,
+        });
+        return { ...route, hops: 1 };
+    }
+    const pool = await poolHelper.getUniswapCompatibleTokenPool(tokenIn);
+    const path = [tokenIn, weth, tokenOut];
+    const route = await poolHelper.getTokensForStableQuote({
+        path,
+        inputAmount: amountIn,
+        slippage,
+        exchangeFactory: pool.exchangeFactory,
+        finalization,
+    });
+    return { ...route, hops: 2 };
+}

package/dist/router/getUniswapV4Route.d.ts

@@ -0,0 +1,42 @@
+import { type Provider } from 'ethers';
+import type { SwapV4Struct } from '../typechain/out/UniswapV4Adapter';
+import type { SwapSimulator } from './simulation';
+import type { Route, RouteSearchParams, V4HookPathKey, V4Path } from './types';
+export interface V4QuoterLike {
+    quoteExactInput: {
+        staticCall: (params: {
+            exactCurrency: string;
+            path: SwapV4Struct['path'];
+            exactAmount: bigint;
+        }) => Promise<[bigint, bigint]>;
+    };
+}
+export declare function connectV4Quoter(address: string, provider: Provider): V4QuoterLike;
+export declare function toAdapterPathKeys(path: V4Path): SwapV4Struct['path'];
+type V4QuoteSource = 'quoter' | 'adapter-preview';
+export interface ApplyV4TollParams {
+    baseToll: {
+        currency: string;
+        amount: bigint;
+    };
+    quotedAmountToReceive: bigint;
+    quoteSource: V4QuoteSource;
+    swapAmountIn: bigint;
+}
+export interface ApplyV4TollResult {
+    toll: {
+        currency: string;
+        amount: bigint;
+    };
+    amountQuoted: bigint;
+    amountToSend: bigint;
+    initialTollAmount: bigint;
+}
+export declare function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }: ApplyV4TollParams): ApplyV4TollResult;
+export declare function toHookAdapterPathKeys(path: V4Path): V4HookPathKey[];
+export interface GetUniswapV4RouteContext {
+    provider: Provider;
+    simulator: SwapSimulator;
+}
+export default function getUniswapV4Route(params: RouteSearchParams, ctx: GetUniswapV4RouteContext): Promise<Route>;
+export {};