@guru-fund/sdk 0.2.9 → 0.2.11

package/dist/addresses.d.ts

@@ -22,6 +22,7 @@ export type GuruProtocolAddresses = {
     readonly factories: Readonly<Partial<Record<FactoryKey, string>>>;
     readonly routers: Readonly<Partial<Record<RouterKey, string>>>;
     readonly quoters: Readonly<Partial<Record<QuoterKey, string>>>;
+    readonly routeBridges?: readonly string[];
     readonly tokens: Readonly<{
         WETH: string;
         USDC: string;

package/dist/addresses.js

@@ -121,6 +121,7 @@ const ROBINHOOD = {
         uniswapV3: '0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7',
         uniswapV4: '0x8dc178efb8111bb0973dd9d722ebeff267c98f94',
     },
+    routeBridges: ['0xc6911796042b15d7fa4f6cde69e245ddcd3d9c31'],
     tokens: {
         WETH: '0x0bd7d308f8e1639fab988df18a8011f41eacad73',
         USDC: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export type { GuruProtocolAddresses, GuruProtocolChainId } from './addresses';
 export { GuruProtocol } from './GuruProtocol';
 export type { GuruProtocolOptions } from './GuruProtocol';
 export type { BuildDepositTxParams, BuildCloseTxParams, BuildHarvestTxParams, BuildTradeTxParams, BuildWithdrawTxParams, } from './txBuilders';
+export type { BuildTradesTxParams } from './txBuilders/buildTradesTx';
 export type { QuoteDepositParams, QuoteDepositResult, QuoteDepositLogs, } from './quotes/quoteDeposit';
 export type { QuoteWithdrawalParams, QuoteWithdrawalResult, QuoteWithdrawalLogs, } from './quotes/quoteWithdrawal';
 export type { QuoteTradeParams, QuoteTradeResult } from './quotes/quoteTrade';

package/dist/quotes/quoteTrade.d.ts

@@ -13,6 +13,8 @@ export interface QuoteTradeContext extends RouterContext {
     chainId: GuruProtocolChainId;
 }
 export interface QuoteTradeResult extends Route {
+    routes: Route[];
     txData: TransactionRequest;
 }
+export declare function bestOfDirectAndComposite(direct: () => Promise<Route>, composite: () => Promise<Route[]>): Promise<Route[]>;
 export default function quoteTrade(params: QuoteTradeParams, ctx: QuoteTradeContext): Promise<QuoteTradeResult>;

package/dist/quotes/quoteTrade.js

@@ -1,9 +1,53 @@
 import { getGuruProtocolAddresses, } from '../addresses.js';
 import compareAddresses from '../helpers/compareAddresses.js';
 import { getRouteIn, getRouteOut } from '../router/index.js';
+import { encodeVaultExecute } from '../router/simulation.js';
 import { quoteTradeSchema } from '../schemas/quoteTrade.js';
 import buildTradeTx from '../txBuilders/buildTradeTx.js';
+import buildTradesTx from '../txBuilders/buildTradesTx.js';
 import { FundLedger__factory, Protocol__factory } from '../typechain/index.js';
+async function buildCompositeWethRoute(routeParams, weth, controllerAddress, vaultAddress, ctx) {
+    const first = await getRouteIn({ ...routeParams, tokenOut: weth }, ctx);
+    const prefixTxs = [
+        {
+            from: controllerAddress,
+            to: vaultAddress,
+            callData: encodeVaultExecute(String(first.adapter), String(first.callData)),
+        },
+    ];
+    const second = await getRouteIn({
+        ...routeParams,
+        tokenIn: weth,
+        amountIn: BigInt(first.data.amountToReceive),
+        prefixTxs,
+    }, ctx);
+    return [first, second];
+}
+export async function bestOfDirectAndComposite(direct, composite) {
+    const [directResult, compositeResult] = await Promise.allSettled([
+        direct(),
+        composite(),
+    ]);
+    if (directResult.status === 'rejected' &&
+        directResult.reason instanceof Error &&
+        (directResult.reason.message.includes('TOKEN_LOCKED_BY_V4_HOOK') ||
+            directResult.reason.message.includes('UNISWAP_V4_HOOK_ROUTE_REVERTED'))) {
+        throw directResult.reason;
+    }
+    if (directResult.status === 'fulfilled' &&
+        compositeResult.status === 'fulfilled') {
+        const compositeRoute = compositeResult.value.at(-1);
+        return BigInt(directResult.value.data.amountToReceive) >=
+            BigInt(compositeRoute.data.amountToReceive)
+            ? [directResult.value]
+            : compositeResult.value;
+    }
+    if (directResult.status === 'fulfilled')
+        return [directResult.value];
+    if (compositeResult.status === 'fulfilled')
+        return compositeResult.value;
+    throw directResult.reason;
+}
 export default async function quoteTrade(params, ctx) {
     const parsed = quoteTradeSchema.parse(params);
     const provider = ctx.provider;
@@ -27,25 +71,43 @@ export default async function quoteTrade(params, ctx) {
         ledger.controller(),
         ledger.manager(),
     ]);
-    const route = await getRoute({
+    const slippageE2 = parsed.maxSlippage != null
+        ? Number(parsed.maxSlippage / 10n)
+        : undefined;
+    const routeParams = {
         chainId: ctx.chainId,
         tokenIn: parsed.tokenIn,
         tokenOut: parsed.tokenOut,
         amountIn: parsed.amountIn,
-        slippageE2: parsed.maxSlippage != null
-            ? Number(parsed.maxSlippage / 10n)
-            : undefined,
+        slippageE2,
         account: vaultAddress,
         vault: vaultAddress,
-    }, ctx);
-    return {
-        ...route,
-        txData: buildTradeTx({
+    };
+    const weth = addresses.tokens.WETH;
+    const routes = compareAddresses(parsed.tokenIn, weth) ||
+        compareAddresses(parsed.tokenOut, weth)
+        ? [await getRoute(routeParams, ctx)]
+        : await bestOfDirectAndComposite(() => getRoute(routeParams, ctx), () => buildCompositeWethRoute(routeParams, weth, controllerAddress, vaultAddress, ctx));
+    const route = routes.at(-1);
+    const txData = routes.length === 1
+        ? buildTradeTx({
             controller: controllerAddress,
             ledger: parsed.ledger,
             adapter: String(route.adapter),
             callData: String(route.callData),
             from: manager,
-        }),
+        })
+        : buildTradesTx({
+            controller: controllerAddress,
+            ledger: parsed.ledger,
+            adapters: routes.map((item) => String(item.adapter)),
+            callData: routes.map((item) => String(item.callData)),
+            from: manager,
+        });
+    return {
+        ...route,
+        routes,
+        hops: routes.reduce((sum, item) => sum + item.hops, 0),
+        txData,
     };
 }

package/dist/router/getFallbackRoutes.js

@@ -2,6 +2,28 @@ import compareAddresses from '../helpers/compareAddresses.js';
 import { FundVault__factory } from '../typechain/index.js';
 import PoolHelper from './poolHelper.js';
 import { quoteWethTrade } from './quoteWethTrade.js';
+async function tryWethBridgeV2Route(poolHelper, input, finalization) {
+    const factory = poolHelper.addresses.factories.uniswapV2;
+    if (!factory || !poolHelper.addresses.adapters.uniswapV2)
+        return null;
+    for (const bridge of poolHelper.addresses.routeBridges ?? []) {
+        try {
+            return await quoteWethTrade({
+                feeTier: 0,
+                input: {
+                    ...input,
+                    path: [input.tokenIn, bridge, input.tokenOut],
+                    exchangeFactory: factory,
+                },
+                poolHelper,
+                finalization,
+            });
+        }
+        catch {
+        }
+    }
+    return null;
+}
 async function tryDirectAerodromeV2RouteIn(poolHelper, { tokenIn, tokenOut, amountIn, slippage, finalization, }) {
     const factory = poolHelper.addresses.factories.aerodromeV2;
     if (!factory || !poolHelper.addresses.adapters.aerodromeV2)
@@ -61,14 +83,22 @@ export async function getFallbackRouteIn(params, ctx) {
         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,
-        });
+        try {
+            const pairedToken = compareAddresses(tokenIn, weth) ? tokenOut : tokenIn;
+            const coinTokenPool = await poolHelper.getUniswapCompatibleTokenPool(pairedToken);
+            return await quoteWethTrade({
+                feeTier: coinTokenPool.feeTier,
+                input: { tokenIn, tokenOut, amountIn, slippage },
+                poolHelper,
+                finalization,
+            });
+        }
+        catch (directError) {
+            const bridged = await tryWethBridgeV2Route(poolHelper, { tokenIn, tokenOut, amountIn, slippage }, finalization);
+            if (bridged)
+                return bridged;
+            throw directError;
+        }
     }
     const directAerodrome = await tryDirectAerodromeV2RouteIn(poolHelper, {
         tokenIn,
@@ -113,15 +143,22 @@ export async function getFallbackRouteOut(params, ctx) {
         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 };
+        try {
+            const pairedToken = compareAddresses(tokenIn, weth) ? tokenOut : tokenIn;
+            const coinTokenPool = await poolHelper.getUniswapCompatibleTokenPool(pairedToken);
+            return await quoteWethTrade({
+                feeTier: coinTokenPool.feeTier,
+                input: { tokenIn, tokenOut, amountIn, slippage },
+                poolHelper,
+                finalization,
+            });
+        }
+        catch (directError) {
+            const bridged = await tryWethBridgeV2Route(poolHelper, { tokenIn, tokenOut, amountIn, slippage }, finalization);
+            if (bridged)
+                return bridged;
+            throw directError;
+        }
     }
     const directAerodrome = await tryDirectAerodromeV2RouteOut(poolHelper, {
         tokenIn,

package/dist/router/index.js

@@ -7,6 +7,7 @@ import getUniswapV4Route, { connectV4Quoter, toAdapterPathKeys, } from './getUni
 import getVeloraRoute from './getVeloraRoute.js';
 import { stablecoinAddresses } from './helpers.js';
 import PoolHelper from './poolHelper.js';
+import { V4_ZERO_ADDRESS } from './constants.js';
 import { discoverV4Paths } from './v4PoolDiscovery.js';
 const AERO_V3_FACTORY_ABI = [
     'function getPool(address tokenA, address tokenB, int24 tickSpacing) view returns (address pool)',
@@ -342,6 +343,11 @@ async function _priceViaV4Pools(token, oneToken, getWethUsd, ctx) {
         }
         return best > 0n ? best : null;
     };
+    const inNative = await quoteVia(V4_ZERO_ADDRESS);
+    if (inNative !== null) {
+        const wethUsd = await getWethUsd();
+        return (inNative * wethUsd) / WETH_UNIT;
+    }
     const inUsdc = await quoteVia(addresses.tokens.USDG ?? addresses.tokens.USDC);
     if (inUsdc !== null) {
         return inUsdc * 10n ** 12n;

package/dist/router/poolHelper.d.ts

@@ -52,13 +52,14 @@ export type QuoteRequest = {
     swapType?: SwapType;
     tokenAmount: bigint;
     slippage?: bigint;
-    path: [string, string];
+    path: string[];
+    exchangeFactory?: string;
     requireSwappable?: boolean;
 };
 type VersionSpecificQuoteRequest = Omit<QuoteRequest, 'path' | 'slippage'> & {
     exchangeFactory: string;
     feeTier: FeeTier;
-    path: [string, string];
+    path: string[];
     slippage: bigint;
     poolAddress?: string;
 };
@@ -115,7 +116,7 @@ export default class PoolHelper {
         exchangeFactory?: string;
         swappableOnly?: boolean;
     }): Promise<Pool>;
-    getBestQuote({ swapType, tokenAmount, slippage, path, requireSwappable, }: QuoteRequest): Promise<Quote>;
+    getBestQuote({ swapType, tokenAmount, slippage, path, requireSwappable, exchangeFactory, }: QuoteRequest): Promise<Quote>;
     getV2Quote({ swapType, tokenAmount, exchangeFactory, path, feeTier, slippage, }: VersionSpecificQuoteRequest): Promise<Quote>;
     getV3Quote({ swapType, tokenAmount, exchangeFactory, path, feeTier, slippage, poolAddress, }: VersionSpecificQuoteRequest): Promise<Quote>;
     getStableForTokenQuote({ path, inputAmount, slippage, exchangeFactory, finalization, }: StableQuoteRequest): Promise<StableQuoteResult>;

package/dist/router/poolHelper.js

@@ -327,7 +327,7 @@ export default class PoolHelper {
         }
         return pools[0];
     }
-    async getBestQuote({ swapType = SwapType.EXACT_INPUT, tokenAmount, slippage = 500n, path, requireSwappable = true, }) {
+    async getBestQuote({ swapType = SwapType.EXACT_INPUT, tokenAmount, slippage = 500n, path, requireSwappable = true, exchangeFactory, }) {
         const weth = this.addresses.tokens.WETH;
         if (!path.some((t) => compareAddresses(t, weth))) {
             throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: WETH not in path`);
@@ -335,6 +335,7 @@ export default class PoolHelper {
         const token = path.find((t) => !compareAddresses(t, weth));
         const pools = await this.getUniswapCompatibleTokenPools(token, {
             swappableOnly: requireSwappable,
+            exchangeFactory,
         });
         if (pools.length === 0) {
             throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: token=${token}`);
@@ -406,6 +407,9 @@ export default class PoolHelper {
         };
     }
     async getV3Quote({ swapType = SwapType.EXACT_INPUT, tokenAmount, exchangeFactory, path, feeTier, slippage, poolAddress, }) {
+        if (path.length !== 2) {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: V3 multi-hop requires per-hop fee tiers`);
+        }
         const [$INPUT, $OUTPUT] = path;
         const dex = this.getDexData(exchangeFactory);
         if (dex.type !== 'v3') {
@@ -811,7 +815,8 @@ export default class PoolHelper {
     }
     _adjustTokenAmountForSwapFee(tokenAmount, swapFeePercentage, swapType, path) {
         const weth = this.addresses.tokens.WETH;
-        const shouldAdjust = compareAddresses(path[Number(swapType)], weth);
+        const tokenEndpoint = swapType === SwapType.EXACT_INPUT ? path[0] : path.at(-1);
+        const shouldAdjust = compareAddresses(tokenEndpoint, weth);
         if (!shouldAdjust) {
             return { adjustedTokenAmount: tokenAmount, swapFee: 0n };
         }
@@ -826,7 +831,8 @@ export default class PoolHelper {
         const sign = swapType === SwapType.EXACT_INPUT ? -1n : 1n;
         const slippageTolerance = calcSlippageTolerance(quote, slippage) * sign;
         const quoteWithSlippage = quote + slippageTolerance;
-        const shouldAdjustQuote = !compareAddresses(path[Number(swapType)], weth);
+        const quoteEndpoint = swapType === SwapType.EXACT_INPUT ? path.at(-1) : path[0];
+        const shouldAdjustQuote = compareAddresses(quoteEndpoint, weth);
         if (!shouldAdjustQuote) {
             return { adjustedQuote: quoteWithSlippage, swapFee: 0n };
         }

package/dist/router/quoteWethTrade.d.ts

@@ -7,6 +7,8 @@ export interface QuoteWethTradeParams {
         tokenOut: string;
         amountIn: bigint;
         slippage: bigint;
+        path?: string[];
+        exchangeFactory?: string;
     };
     poolHelper: PoolHelper;
     finalization?: PoolRouteFinalizationContext;

package/dist/router/quoteWethTrade.js

@@ -4,6 +4,7 @@ import { AerodromeV2Adapter__factory, UniswapV2Adapter__factory, UniswapV3Adapte
 import { finalizeRouteQuote } from './finalizeRoute.js';
 export async function quoteWethTrade({ feeTier, input, poolHelper, finalization, }) {
     const weth = poolHelper.addresses.tokens.WETH;
+    const routePath = input.path ?? [input.tokenIn, input.tokenOut];
     const wethIn = compareAddresses(input.tokenIn, weth);
     const wethOut = compareAddresses(input.tokenOut, weth);
     if (!wethIn && !wethOut) {
@@ -11,8 +12,9 @@ export async function quoteWethTrade({ feeTier, input, poolHelper, finalization,
     }
     const quote = await poolHelper.getBestQuote({
         tokenAmount: input.amountIn,
-        path: [input.tokenIn, input.tokenOut],
+        path: routePath,
         slippage: finalization ? 0n : input.slippage,
+        exchangeFactory: input.exchangeFactory,
     });
     const adapter = poolHelper.getLotusAdapter(quote.exchangeFactory);
     const dex = poolHelper.getDexData(quote.exchangeFactory);
@@ -46,7 +48,7 @@ export async function quoteWethTrade({ feeTier, input, poolHelper, finalization,
                 const data = {
                     amountToSend: input.amountIn,
                     amountToReceive,
-                    path: [input.tokenIn, input.tokenOut],
+                    path: routePath,
                     deadline,
                 };
                 return {
@@ -86,7 +88,7 @@ export async function quoteWethTrade({ feeTier, input, poolHelper, finalization,
             adapter,
             account: finalization.account,
             path: dex.type === 'v2'
-                ? [input.tokenIn, input.tokenOut]
+                ? routePath
                 : [
                     {
                         tokenIn: input.tokenIn,
@@ -119,7 +121,7 @@ export async function quoteWethTrade({ feeTier, input, poolHelper, finalization,
             currency: weth,
             amount: finalized.finalTollAmount,
         },
-        hops: 1,
+        hops: routePath.length - 1,
         effectiveSlippageBps: finalized.effectiveSlippageBps,
     };
 }

package/dist/router/simulation.js

@@ -40,10 +40,14 @@ export async function findMaxPassingAmountToReceive({ chainId, blockNumber, cont
         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);
+    const successIndices = [];
+    for (const [index, amount] of candidates.entries()) {
+        const result = await simulate(encodeVaultExecute(adapter, buildCallDataForAmount(amount)));
+        if (result.success)
+            successIndices.push(index);
+        if (successIndices.length === 2)
+            break;
+    }
     if (successIndices.length === 0) {
         console.warn('Found no successful simulations for executable route quote', {
             chainId,

package/dist/router/v4PoolDiscovery.d.ts

@@ -23,9 +23,11 @@ interface DexscreenerPair {
     liquidity?: {
         usd?: number;
     };
+    pairCreatedAt?: 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 findKnownV4BridgeKeys(chainId: GuruProtocolChainId, tokenIn: string, tokenOut: string): V4PoolKey[];
 export declare function _clearV4DiscoveryCache(): void;
 export {};

package/dist/router/v4PoolDiscovery.js

@@ -19,8 +19,37 @@ const V4_CHAIN_CONFIG = {
         deployBlock: 0,
     },
 };
+const KNOWN_V4_BRIDGE_KEYS = {
+    4663: [
+        {
+            currency0: V4_ZERO_ADDRESS,
+            currency1: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+            fee: 25,
+            tickSpacing: 1,
+            hooks: V4_ZERO_ADDRESS,
+        },
+        {
+            currency0: V4_ZERO_ADDRESS,
+            currency1: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+            fee: 100,
+            tickSpacing: 1,
+            hooks: V4_ZERO_ADDRESS,
+        },
+        {
+            currency0: V4_ZERO_ADDRESS,
+            currency1: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+            fee: 500,
+            tickSpacing: 10,
+            hooks: V4_ZERO_ADDRESS,
+        },
+    ],
+};
 const POOL_INITIALIZE_TOPIC = '0xdd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438';
 export function isSafeDiscoveredV4PoolKey(key) {
+    const dynamicFeeFlag = 0x800000;
+    if (key.fee === dynamicFeeFlag) {
+        return !compareAddresses(key.hooks, V4_ZERO_ADDRESS);
+    }
     return key.fee >= 0 && key.fee <= V4_DISCOVERY_MAX_LP_FEE;
 }
 export function computeV4PoolId(key) {
@@ -66,18 +95,63 @@ export function stitchNativeBridgeV4Paths(firstLegs, secondLegs) {
     return paths;
 }
 const poolKeyCache = new Map();
-async function resolvePoolKey(chainId, poolId, provider) {
+async function resolvePoolKey(chainId, poolId, provider, pairCreatedAt) {
     const cacheKey = `${chainId}:${poolId}`;
     const cached = poolKeyCache.get(cacheKey);
     if (cached)
         return cached;
     const config = V4_CHAIN_CONFIG[chainId];
-    const logs = await provider.getLogs({
+    const filter = {
         address: config.poolManager,
         topics: [POOL_INITIALIZE_TOPIC, poolId],
         fromBlock: config.deployBlock,
         toBlock: 'latest',
-    });
+    };
+    let logs;
+    try {
+        logs = await provider.getLogs(filter);
+    }
+    catch {
+        logs = [];
+        const latestBlock = await provider.getBlockNumber();
+        const chunkSize = 9_999;
+        if (pairCreatedAt) {
+            let low = config.deployBlock;
+            let high = latestBlock;
+            const targetTimestamp = Math.floor(pairCreatedAt / 1_000);
+            while (low < high) {
+                const middle = Math.floor((low + high) / 2);
+                const block = await provider.getBlock(middle);
+                if (!block)
+                    break;
+                if (block.timestamp < targetTimestamp)
+                    low = middle + 1;
+                else
+                    high = middle;
+            }
+            const fromBlock = Math.max(config.deployBlock, low - 5_000);
+            const toBlock = Math.min(latestBlock, fromBlock + chunkSize);
+            logs = await provider.getLogs({
+                ...filter,
+                fromBlock,
+                toBlock,
+            });
+        }
+        if (logs.length === 0) {
+            for (let toBlock = latestBlock; toBlock >= config.deployBlock; toBlock -= chunkSize + 1) {
+                const fromBlock = Math.max(config.deployBlock, toBlock - chunkSize);
+                const chunk = await provider.getLogs({
+                    ...filter,
+                    fromBlock,
+                    toBlock,
+                });
+                if (chunk.length > 0) {
+                    logs = chunk;
+                    break;
+                }
+            }
+        }
+    }
     const log = logs[0];
     if (!log)
         return null;
@@ -142,6 +216,7 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
     const isMajor = (token) => majors.some((major) => compareAddresses(major, token));
     const queryOrder = isMajor(tokenIn) ? [tokenOut, tokenIn] : [tokenIn, tokenOut];
     let poolIds = [];
+    const pairCreatedAtByPoolId = new Map();
     for (const queryToken of queryOrder) {
         const response = await fetch(`${endpoint}/${config.dexscreenerSlug}/${queryToken}`);
         if (!response.ok) {
@@ -149,15 +224,23 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
         }
         const pairs = (await response.json());
         poolIds = selectV4PairPoolIds(pairs, tokenIn, tokenOut);
-        if (poolIds.length > 0)
+        if (poolIds.length > 0) {
+            for (const pair of pairs) {
+                if (!pair.pairAddress || !pair.pairCreatedAt)
+                    continue;
+                pairCreatedAtByPoolId.set(pair.pairAddress.toLowerCase(), pair.pairCreatedAt);
+            }
             break;
+        }
     }
-    const keys = await Promise.all(poolIds.map((poolId) => resolvePoolKey(chainId, poolId, provider)));
+    const keys = await Promise.all(poolIds.map((poolId) => resolvePoolKey(chainId, poolId, provider, pairCreatedAtByPoolId.get(poolId))));
     const resolvedKeys = keys.filter((key) => key !== null && isSafeDiscoveredV4PoolKey(key));
-    const onchainKeys = resolvedKeys.length > 0
+    const knownKeys = findKnownV4BridgeKeys(chainId, tokenIn, tokenOut);
+    const onchainKeys = resolvedKeys.length > 0 || knownKeys.length > 0
         ? []
-        : await discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider);
+        : await discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider).catch(() => []);
     const paths = resolvedKeys
+        .concat(knownKeys)
         .concat(onchainKeys)
         .filter((key) => key !== null)
         .map((key) => [
@@ -172,6 +255,12 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
     ]);
     return paths;
 }
+export function findKnownV4BridgeKeys(chainId, tokenIn, tokenOut) {
+    return (KNOWN_V4_BRIDGE_KEYS[chainId] ?? []).filter((key) => (compareAddresses(key.currency0, tokenIn) &&
+        compareAddresses(key.currency1, tokenOut)) ||
+        (compareAddresses(key.currency0, tokenOut) &&
+            compareAddresses(key.currency1, tokenIn)));
+}
 async function discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider) {
     const config = V4_CHAIN_CONFIG[chainId];
     const [currency0, currency1] = tokenIn.toLowerCase() < tokenOut.toLowerCase()

package/dist/txBuilders/buildTradesTx.d.ts

@@ -0,0 +1,9 @@
+import type { TransactionRequest } from 'ethers';
+export interface BuildTradesTxParams {
+    controller: string;
+    ledger: string;
+    adapters: string[];
+    callData: string[];
+    from: string;
+}
+export default function buildTradesTx(params: BuildTradesTxParams): TransactionRequest;

package/dist/txBuilders/buildTradesTx.js

@@ -0,0 +1,9 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildTradesTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('executeTrades', [params.ledger, params.adapters, params.callData]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/index.d.ts

@@ -7,4 +7,6 @@ export type { BuildWithdrawTxParams } from './buildWithdrawTx';
 export { default as buildHarvestTx } from './buildHarvestTx';
 export type { BuildHarvestTxParams } from './buildHarvestTx';
 export { default as buildTradeTx } from './buildTradeTx';
+export { default as buildTradesTx } from './buildTradesTx';
 export type { BuildTradeTxParams } from './buildTradeTx';
+export type { BuildTradesTxParams } from './buildTradesTx';

package/dist/txBuilders/index.js

@@ -3,3 +3,4 @@ export { default as buildCloseTx } from './buildCloseTx.js';
 export { default as buildWithdrawTx } from './buildWithdrawTx.js';
 export { default as buildHarvestTx } from './buildHarvestTx.js';
 export { default as buildTradeTx } from './buildTradeTx.js';
+export { default as buildTradesTx } from './buildTradesTx.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@guru-fund/sdk",
-    "version": "0.2.9",
+    "version": "0.2.11",
     "description": "Guru Protocol SDK — quote + transaction builders for on-chain managed funds.",
     "license": "MIT",
     "type": "module",