@guru-fund/sdk 0.2.3 → 0.2.5

package/dist/quotes/quoteDeposit.d.ts

@@ -37,5 +37,12 @@ export interface QuoteDepositResult {
     txData: TransactionRequest;
     decodeLogs: (logs: SimulationLog[]) => QuoteDepositLogs | null;
 }
+type DepositAllocationQuote = {
+    asset: Fund.Asset;
+    amountIn: bigint;
+    amountOut: bigint;
+};
 export declare function allocateDepositInputAmounts(assets: Fund.Asset[], totalAmount: bigint, totalValueLocked: bigint): Map<string, bigint>;
+export declare function rebalanceDepositInputAmounts(quotes: DepositAllocationQuote[], totalAmount: bigint): Map<string, bigint>;
 export default function quoteDeposit(params: QuoteDepositParams, ctx: QuoteDepositContext): Promise<QuoteDepositResult>;
+export {};

package/dist/quotes/quoteDeposit.js

@@ -8,28 +8,30 @@ import { quoteDepositSchema } from '../schemas/quoteDeposit.js';
 import buildDepositTx from '../txBuilders/buildDepositTx.js';
 import { FundLedger__factory } from '../typechain/index.js';
 const MAX_UINT256 = (1n << 256n) - 1n;
+const MIN_ROUTE_INPUT_AMOUNT = 2n;
+const ROUTE_AWARE_ALLOCATION_PASSES = 1;
 const minBigint = (a, b) => (a < b ? a : b);
 const slippageE2For = (settings, token) => {
     const slippage = settings?.[token.toLowerCase()];
     return slippage == null ? undefined : Number(BigInt(slippage) / 10n);
 };
 const assetUsd1e18Value = (asset) => (asset.usd1e18Price * asset.balance) / Token.unitFor(asset.token.decimals);
-export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocked) {
+function allocateWeightedInputAmounts(items, totalAmount) {
     const allocations = new Map();
-    if (totalAmount === 0n || totalValueLocked === 0n) {
-        for (const asset of assets) {
-            allocations.set(asset.token.address.toLowerCase(), 0n);
-        }
+    if (totalAmount === 0n) {
+        for (const item of items)
+            allocations.set(item.key, 0n);
         return allocations;
     }
-    const weighted = assets.map((asset) => {
-        const usdValue = assetUsd1e18Value(asset);
-        const weightedAmount = totalAmount * usdValue;
-        const amount = weightedAmount / totalValueLocked;
+    const weighted = items.map((item) => {
+        const weightedAmount = totalAmount * item.weight;
+        const amount = item.denominator === 0n ? 0n : weightedAmount / item.denominator;
         return {
-            asset,
+            ...item,
             amount,
-            remainder: weightedAmount % totalValueLocked,
+            remainder: item.denominator === 0n
+                ? 0n
+                : weightedAmount % item.denominator,
         };
     });
     const allocated = weighted.reduce((sum, item) => sum + item.amount, 0n);
@@ -38,11 +40,116 @@ export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocke
         .sort((a, b) => a.remainder === b.remainder ? 0 : a.remainder > b.remainder ? -1 : 1)
         .forEach((item) => {
         const extra = remainder > 0n ? 1n : 0n;
-        allocations.set(item.asset.token.address.toLowerCase(), item.amount + extra);
+        allocations.set(item.key, item.amount + extra);
         remainder -= extra;
     });
+    const zeroRoundedAssets = weighted
+        .filter((item) => item.balance > 0n && (allocations.get(item.key) ?? 0n) === 0n)
+        .sort((a, b) => a.remainder === b.remainder ? 0 : a.remainder > b.remainder ? -1 : 1);
+    for (const item of zeroRoundedAssets) {
+        const donor = weighted
+            .filter((candidate) => candidate.key !== item.key)
+            .sort((a, b) => {
+            const aAmount = allocations.get(a.key) ?? 0n;
+            const bAmount = allocations.get(b.key) ?? 0n;
+            return aAmount === bAmount ? 0 : aAmount > bAmount ? -1 : 1;
+        })
+            .find((candidate) => (allocations.get(candidate.key) ?? 0n) >
+            MIN_ROUTE_INPUT_AMOUNT);
+        if (!donor)
+            break;
+        allocations.set(donor.key, (allocations.get(donor.key) ?? 0n) - MIN_ROUTE_INPUT_AMOUNT);
+        allocations.set(item.key, MIN_ROUTE_INPUT_AMOUNT);
+    }
     return allocations;
 }
+export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocked) {
+    if (totalAmount === 0n || totalValueLocked === 0n) {
+        const allocations = new Map();
+        for (const asset of assets) {
+            allocations.set(asset.token.address.toLowerCase(), 0n);
+        }
+        return allocations;
+    }
+    return allocateWeightedInputAmounts(assets.map((asset) => ({
+        key: asset.token.address.toLowerCase(),
+        weight: assetUsd1e18Value(asset),
+        denominator: totalValueLocked,
+        balance: asset.balance,
+    })), totalAmount);
+}
+export function rebalanceDepositInputAmounts(quotes, totalAmount) {
+    let denominator = 0n;
+    const weights = quotes.map(({ asset, amountIn, amountOut }) => {
+        let weight = 0n;
+        if (asset.balance > 0n && amountIn > 0n && amountOut > 0n) {
+            const inputRatio = (amountOut * UNIT) / asset.balance;
+            if (inputRatio > 0n) {
+                weight = (amountIn * UNIT) / inputRatio;
+            }
+        }
+        denominator += weight;
+        return {
+            key: asset.token.address.toLowerCase(),
+            weight,
+            denominator: 0n,
+            balance: asset.balance,
+        };
+    });
+    if (denominator === 0n) {
+        return new Map(quotes.map(({ asset, amountIn }) => [
+            asset.token.address.toLowerCase(),
+            amountIn,
+        ]));
+    }
+    return allocateWeightedInputAmounts(weights.map((item) => ({ ...item, denominator })), totalAmount);
+}
+function allocationsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [key, value] of a) {
+        if (b.get(key) !== value)
+            return false;
+    }
+    return true;
+}
+async function quoteDepositAllocations({ inputAllocations, coinData, fundData, parsed, ctx, vault, }) {
+    const allocationQuotes = [];
+    if (coinData) {
+        const amountIn = inputAllocations.get(coinData.token.address.toLowerCase()) ?? 0n;
+        if (coinData.balance > 0n && amountIn === 0n) {
+            throw new Error(`Deposit amount is too small to allocate input for asset ${coinData.token.address}`);
+        }
+        allocationQuotes.push({
+            asset: coinData,
+            amountIn,
+            amountOut: amountIn,
+        });
+    }
+    const assetsToSwap = fundData.assets.filter((asset) => !compareAddresses(asset.token.address, parsed.coin));
+    const routeResults = await Promise.all(assetsToSwap.map(async (asset) => {
+        const amountIn = inputAllocations.get(asset.token.address.toLowerCase()) ?? 0n;
+        if (asset.balance > 0n && amountIn === 0n) {
+            throw new Error(`Deposit amount is too small to allocate input for asset ${asset.token.address}`);
+        }
+        const route = await getRouteIn({
+            chainId: ctx.chainId,
+            tokenIn: parsed.coin,
+            tokenOut: asset.token.address,
+            amountIn,
+            account: parsed.account,
+            vault,
+            slippageE2: slippageE2For(parsed.slippageSettings, asset.token.address),
+        }, ctx);
+        allocationQuotes.push({
+            asset,
+            amountIn,
+            amountOut: BigInt(route.data.amountToReceive),
+        });
+        return { asset, amountIn, route };
+    }));
+    return { allocationQuotes, routeResults };
+}
 export default async function quoteDeposit(params, ctx) {
     const parsed = quoteDepositSchema.parse(params);
     if (parsed.referrerFeeBps < 0n || parsed.referrerFeeBps > MAX_BPS) {
@@ -65,32 +172,36 @@ export default async function quoteDeposit(params, ctx) {
     let fees = (originalAmount * referrerFeeBps) / MAX_BPS;
     const adjustedAmount = originalAmount - fees;
     const coinData = fundData.assets.find((asset) => compareAddresses(asset.token.address, parsed.coin));
-    const inputAllocations = allocateDepositInputAmounts(fundData.assets, adjustedAmount, fundData.totalValueLocked);
-    const coinInputAmount = coinData
-        ? (inputAllocations.get(coinData.token.address.toLowerCase()) ?? 0n)
-        : 0n;
-    if (coinData && coinData.balance > 0n && coinInputAmount === 0n) {
-        throw new Error(`Deposit amount is too small to allocate input for asset ${coinData.token.address}`);
-    }
-    let lowestInputRatio = coinData && coinData.balance > 0n
-        ? (coinInputAmount * UNIT) / coinData.balance
-        : MAX_UINT256;
-    const assetsToSwap = fundData.assets.filter((asset) => !compareAddresses(asset.token.address, parsed.coin));
-    const routeResults = await Promise.all(assetsToSwap.map(async (asset) => {
-        const amountIn = inputAllocations.get(asset.token.address.toLowerCase()) ?? 0n;
-        if (asset.balance > 0n && amountIn === 0n) {
-            throw new Error(`Deposit amount is too small to allocate input for asset ${asset.token.address}`);
-        }
-        const route = await getRouteIn({
-            chainId: ctx.chainId,
-            tokenIn: parsed.coin,
-            tokenOut: asset.token.address,
-            amountIn,
-            account: parsed.account,
+    let inputAllocations = allocateDepositInputAmounts(fundData.assets, adjustedAmount, fundData.totalValueLocked);
+    let quoted = await quoteDepositAllocations({
+        inputAllocations,
+        coinData,
+        fundData,
+        parsed,
+        ctx,
+        vault,
+    });
+    for (let i = 0; i < ROUTE_AWARE_ALLOCATION_PASSES; i++) {
+        const rebalanced = rebalanceDepositInputAmounts(quoted.allocationQuotes, adjustedAmount);
+        if (allocationsEqual(inputAllocations, rebalanced))
+            break;
+        inputAllocations = rebalanced;
+        quoted = await quoteDepositAllocations({
+            inputAllocations,
+            coinData,
+            fundData,
+            parsed,
+            ctx,
             vault,
-        }, ctx);
-        return { asset, route };
-    }));
+        });
+    }
+    let lowestInputRatio = MAX_UINT256;
+    for (const { asset, amountOut } of quoted.allocationQuotes) {
+        if (asset.balance === 0n)
+            continue;
+        lowestInputRatio = minBigint(lowestInputRatio, (amountOut * UNIT) / asset.balance);
+    }
+    const routeResults = quoted.routeResults;
     const coinToken = await new Token(parsed.coin, provider).metadata();
     const coinUsd1e18Price = await ctx.getPriceUsd1e18(parsed.coin);
     const externalTokenMetadata = new Map();
@@ -142,7 +253,6 @@ export default async function quoteDeposit(params, ctx) {
             callData: route.callData,
         });
         fees += await tollToCoinUnits(route.toll.amount, route.toll.currency);
-        lowestInputRatio = minBigint(lowestInputRatio, (BigInt(route.data.amountToReceive) * UNIT) / asset.balance);
         const bps = route.effectiveSlippageBps;
         if (bps != null) {
             const bpsN = BigInt(bps);

package/dist/router/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const VELORA_ENDPOINT = "https://api.velora.xyz/swap";
-export declare const SUPPORTED_DEXS: readonly ["UniswapV2", "UniswapV3", "UniswapV4", "AerodromeV2", "PancakeSwapV2", "PancakeSwapV3"];
+export declare const SUPPORTED_DEXS: readonly ["UniswapV2", "UniswapV3", "UniswapV4", "AerodromeV3", "AerodromeV2", "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;

package/dist/router/constants.js

@@ -3,6 +3,7 @@ export const SUPPORTED_DEXS = [
     'UniswapV2',
     'UniswapV3',
     'UniswapV4',
+    'AerodromeV3',
     'AerodromeV2',
     'PancakeSwapV2',
     'PancakeSwapV3',

package/dist/router/getUniswapV4Route.d.ts

@@ -15,6 +15,7 @@ export declare function connectV4Quoter(address: string, provider: Provider): V4
 export declare function toAdapterPathKeys(path: V4Path): SwapV4Struct['path'];
 type V4QuoteSource = 'quoter' | 'adapter-preview';
 export interface ApplyV4TollParams {
+    tollIn: boolean;
     baseToll: {
         currency: string;
         amount: bigint;
@@ -32,7 +33,7 @@ export interface ApplyV4TollResult {
     amountToSend: bigint;
     initialTollAmount: bigint;
 }
-export declare function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }: ApplyV4TollParams): ApplyV4TollResult;
+export declare function applyV4Toll({ tollIn, baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }: ApplyV4TollParams): ApplyV4TollResult;
 export declare function toHookAdapterPathKeys(path: V4Path): V4HookPathKey[];
 export interface GetUniswapV4RouteContext {
     provider: Provider;

package/dist/router/getUniswapV4Route.js

@@ -45,15 +45,17 @@ function isV4HookLockedError(reason) {
     }
     return false;
 }
-export function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }) {
+export function applyV4Toll({ tollIn, 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;
+            if (!tollIn) {
+                toll.amount = quotedAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
         }
         initialTollAmount = 0n;
     }
@@ -194,7 +196,7 @@ export default async function getUniswapV4Route(params, ctx) {
         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 { tollIn, 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');
@@ -254,6 +256,7 @@ export default async function getUniswapV4Route(params, ctx) {
     const selectedAdapter = bestQuote.adapter ?? adapter;
     const bestPath = bestQuote.path;
     const { toll, amountQuoted, amountToSend, initialTollAmount } = applyV4Toll({
+        tollIn,
         baseToll,
         quotedAmountToReceive: bestQuote.amountToReceive,
         quoteSource: bestQuote.source,
@@ -296,6 +299,7 @@ export default async function getUniswapV4Route(params, ctx) {
         amountToSend,
         amountQuoted,
         initialTollAmount,
+        outputTollE3: tollIn ? 0n : undefined,
         maxSlippageE3,
     });
     return {

package/dist/router/getVeloraRoute.js

@@ -20,7 +20,7 @@ export default async function getVeloraRoute(params, ctx) {
         tokenOutDecimals ?? fetchDecimals(tokenOut, provider),
         FundVault__factory.connect(vault, provider).controller(),
     ]);
-    const { baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
+    const { tollIn, baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
     const routes = (await Promise.all(SUPPORTED_DEXS.map(async (dex) => {
         try {
             if (!isDexConfigured(addresses, dex))
@@ -47,6 +47,7 @@ export default async function getVeloraRoute(params, ctx) {
                 dex,
                 cachedPath,
                 amountIn: swapAmountIn,
+                tollIn,
                 toll,
                 vault,
                 controller,

package/dist/router/index.js

@@ -1,4 +1,4 @@
-import { parseEther } from 'ethers';
+import { Contract, parseEther, ZeroAddress } from 'ethers';
 import { getGuruProtocolAddresses, } from '../addresses.js';
 import compareAddresses from '../helpers/compareAddresses.js';
 import { Token } from '../helpers/Token.js';
@@ -7,6 +7,33 @@ import getUniswapV4Route, { connectV4Quoter, toAdapterPathKeys, } from './getUni
 import getVeloraRoute from './getVeloraRoute.js';
 import PoolHelper from './poolHelper.js';
 import { discoverV4Paths } from './v4PoolDiscovery.js';
+const AERO_V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, int24 tickSpacing) view returns (address pool)',
+];
+const V2_FACTORY_ABI = [
+    'function getPair(address tokenA, address tokenB) view returns (address pair)',
+];
+const V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, address[] memory path) view returns (uint256[] memory amounts)',
+];
+const AERO_V2_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, bool stable) view returns (address)',
+];
+const AERO_V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, (address from, address to, bool stable, address factory)[] routes) view returns (uint256[] amounts)',
+];
+const V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)',
+];
+const V3_QUOTER_ABI = [
+    'function quoteExactInputSingle((address tokenIn,address tokenOut,uint256 amountIn,uint24 fee,uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut,uint160 sqrtPriceX96After,uint32 initializedTicksCrossed,uint256 gasEstimate)',
+];
+const AERO_V3_QUOTER_ABI = [
+    'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, int24 tickSpacing, uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+];
+const UNISWAP_V3_FEES = [100, 500, 3000, 10000];
+const PANCAKE_V3_FEES = [100, 500, 2500, 10000];
+const AERODROME_V3_TICK_SPACINGS = [1, 50, 100, 200];
 export async function veloraThenV4Discovery(velora, v4Discovery) {
     try {
         return await velora();
@@ -97,9 +124,7 @@ export async function getPriceUsd1e18(token, ctx) {
     }
     const { decimals } = await new Token(token, ctx.provider).metadata();
     const oneToken = 10n ** BigInt(decimals);
-    const stableUsd = await _priceViaDirectStablePool(token, oneToken, poolHelper, stable, stableDecimals);
-    if (stableUsd !== null)
-        return stableUsd;
+    const stableUsd = await _priceViaDirectStablePool(token, oneToken, poolHelper, stable, stableDecimals, ctx.provider);
     const WETH_UNIT = 10n ** 18n;
     try {
         const wethUsd = await getWethUsd();
@@ -108,33 +133,157 @@ export async function getPriceUsd1e18(token, ctx) {
             path: [token, addresses.tokens.WETH],
             requireSwappable: false,
         });
-        return (oneTokenInWeth * wethUsd) / WETH_UNIT;
+        const wethRouteUsd = (oneTokenInWeth * wethUsd) / WETH_UNIT;
+        return stableUsd !== null && stableUsd > wethRouteUsd
+            ? stableUsd
+            : wethRouteUsd;
     }
     catch (error) {
         const v4Usd = await _priceViaV4Pools(token, oneToken, getWethUsd, ctx);
+        if (stableUsd !== null && v4Usd !== null) {
+            return stableUsd > v4Usd ? stableUsd : v4Usd;
+        }
+        if (stableUsd !== null)
+            return stableUsd;
         if (v4Usd !== null)
             return v4Usd;
         throw error;
     }
 }
-async function _priceViaDirectStablePool(token, oneToken, poolHelper, stable, stableDecimals) {
-    const factory = poolHelper.addresses.factories.aerodromeV2;
-    if (!factory)
-        return null;
-    const route = await poolHelper
-        .getTokensForStableQuote({
-        path: [token, stable],
-        inputAmount: oneToken,
-        slippage: 0n,
-        exchangeFactory: factory,
-    })
-        .catch(() => null);
-    if (!route)
-        return null;
-    const amountToReceive = BigInt(route.data.amountToReceive);
-    if (amountToReceive === 0n)
+async function _priceViaDirectStablePool(token, oneToken, poolHelper, stable, stableDecimals, provider) {
+    const stableUnit = Token.unitFor(stableDecimals);
+    const toUsd1e18 = (amount) => (amount * 10n ** 18n) / stableUnit;
+    const quotes = [];
+    const v2Amount = await _quoteDirectV2StablePools(token, stable, oneToken, poolHelper, provider);
+    if (v2Amount > 0n)
+        quotes.push(v2Amount);
+    const v3Amount = await _quoteDirectV3StablePools(token, stable, oneToken, poolHelper, provider);
+    if (v3Amount > 0n)
+        quotes.push(v3Amount);
+    const aeroV3Amount = await _quoteDirectAerodromeV3StablePool(token, stable, oneToken, poolHelper, provider);
+    if (aeroV3Amount > 0n)
+        quotes.push(aeroV3Amount);
+    if (quotes.length === 0)
         return null;
-    return (amountToReceive * 10n ** 18n) / Token.unitFor(stableDecimals);
+    const best = quotes.reduce((currentBest, amount) => amount > currentBest ? amount : currentBest);
+    return toUsd1e18(best);
+}
+async function _quoteDirectV2StablePools(token, stable, oneToken, poolHelper, provider) {
+    let best = 0n;
+    const quoteStandardV2 = async (factoryAddress, routerAddress) => {
+        if (!factoryAddress || !routerAddress)
+            return;
+        const factory = new Contract(factoryAddress, V2_FACTORY_ABI, provider);
+        const pairAddress = await factory
+            .getPair(token, stable)
+            .catch(() => ZeroAddress);
+        if (pairAddress === ZeroAddress)
+            return;
+        const router = new Contract(routerAddress, V2_ROUTER_ABI, provider);
+        const amounts = await router
+            .getAmountsOut(oneToken, [token, stable])
+            .catch(() => null);
+        const amountOut = amounts?.at(-1) ?? 0n;
+        if (amountOut > best)
+            best = amountOut;
+    };
+    const quoteAerodromeV2 = async (factoryAddress, routerAddress) => {
+        if (!factoryAddress || !routerAddress)
+            return;
+        const factory = new Contract(factoryAddress, AERO_V2_FACTORY_ABI, provider);
+        const router = new Contract(routerAddress, AERO_V2_ROUTER_ABI, provider);
+        await Promise.all([false, true].map(async (stablePool) => {
+            const poolAddress = await factory
+                .getPool(token, stable, stablePool)
+                .catch(() => ZeroAddress);
+            if (poolAddress === ZeroAddress)
+                return;
+            const amounts = await router
+                .getAmountsOut(oneToken, [
+                {
+                    from: token,
+                    to: stable,
+                    stable: stablePool,
+                    factory: factoryAddress,
+                },
+            ])
+                .catch(() => null);
+            const amountOut = amounts?.at(-1) ?? 0n;
+            if (amountOut > best)
+                best = amountOut;
+        }));
+    };
+    await Promise.all([
+        quoteStandardV2(poolHelper.addresses.factories.uniswapV2, poolHelper.addresses.routers.uniswapV2),
+        quoteStandardV2(poolHelper.addresses.factories.pancakeV2, poolHelper.addresses.routers.pancakeV2),
+        quoteAerodromeV2(poolHelper.addresses.factories.aerodromeV2, poolHelper.addresses.routers.aerodromeV2),
+    ]);
+    return best;
+}
+async function _quoteDirectV3StablePools(token, stable, oneToken, poolHelper, provider) {
+    let best = 0n;
+    const quoteFactory = async (factoryAddress, quoterAddress, fees) => {
+        if (!factoryAddress || !quoterAddress)
+            return;
+        const factory = new Contract(factoryAddress, V3_FACTORY_ABI, provider);
+        const quoter = new Contract(quoterAddress, V3_QUOTER_ABI, provider);
+        await Promise.all(fees.map(async (fee) => {
+            const poolAddress = await factory
+                .getPool(token, stable, fee)
+                .catch(() => ZeroAddress);
+            if (poolAddress === ZeroAddress)
+                return;
+            const quote = await quoter.quoteExactInputSingle.staticCall({
+                tokenIn: token,
+                tokenOut: stable,
+                amountIn: oneToken,
+                fee: BigInt(fee),
+                sqrtPriceLimitX96: 0n,
+            }).catch(() => null);
+            const amountOut = quote?.amountOut ?? 0n;
+            if (amountOut > best)
+                best = amountOut;
+        }));
+    };
+    await Promise.all([
+        quoteFactory(poolHelper.addresses.factories.uniswapV3, poolHelper.addresses.quoters.uniswapV3, UNISWAP_V3_FEES),
+        quoteFactory(poolHelper.addresses.factories.pancakeV3, poolHelper.addresses.quoters.pancakeV3, PANCAKE_V3_FEES),
+    ]);
+    return best;
+}
+async function _quoteDirectAerodromeV3StablePool(token, stable, oneToken, poolHelper, provider) {
+    const quoterAddress = poolHelper.addresses.quoters.aerodromeV3;
+    if (!quoterAddress)
+        return 0n;
+    const factories = [
+        poolHelper.addresses.factories.aerodromeV3,
+        poolHelper.addresses.factories.aerodromeV3Bis,
+    ].filter((factory) => Boolean(factory));
+    if (factories.length === 0)
+        return 0n;
+    const quoter = new Contract(quoterAddress, AERO_V3_QUOTER_ABI, provider);
+    let best = 0n;
+    await Promise.all(factories.flatMap((factoryAddress) => {
+        const factory = new Contract(factoryAddress, AERO_V3_FACTORY_ABI, provider);
+        return AERODROME_V3_TICK_SPACINGS.map(async (tickSpacing) => {
+            const poolAddress = await factory
+                .getPool(token, stable, tickSpacing)
+                .catch(() => ZeroAddress);
+            if (poolAddress === ZeroAddress)
+                return;
+            const quote = await quoter.quoteExactInputSingle.staticCall({
+                tokenIn: token,
+                tokenOut: stable,
+                amountIn: oneToken,
+                tickSpacing: BigInt(tickSpacing),
+                sqrtPriceLimitX96: 0n,
+            }).catch(() => null);
+            const amountOut = quote?.amountOut ?? 0n;
+            if (amountOut > best)
+                best = amountOut;
+        });
+    }));
+    return best;
 }
 async function _priceViaV4Pools(token, oneToken, getWethUsd, ctx) {
     const addresses = getGuruProtocolAddresses(ctx.chainId);

package/dist/router/pathCache.js

@@ -32,10 +32,18 @@ export function extractPathFromResponse(dex, response) {
         const swapPath = swap.swapExchanges[0].data.path;
         if (!Array.isArray(swapPath) ||
             typeof swapPath[0]?.tokenIn !== 'string' ||
-            typeof swapPath[0]?.fee !== 'string') {
+            swapPath[0]?.fee == null) {
             throw new Error('Unexpected V3 path structure');
         }
-        combinedPath.push(...swapPath);
+        combinedPath.push(...swapPath.map((hop) => ({
+            tokenIn: hop.tokenIn,
+            tokenOut: hop.tokenOut,
+            fee: String(dex === 'AerodromeV3'
+                ? (hop.tickSpacing ?? hop.fee)
+                : hop.fee),
+            currentFee: hop.currentFee,
+            tickSpacing: hop.tickSpacing,
+        })));
     }
     return { type: 'v3', path: combinedPath, hops: combinedPath.length };
 }

package/dist/router/poolHelper.js

@@ -21,6 +21,9 @@ const V2_PAIR_ABI = [
 const V3_FACTORY_ABI = [
     'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)',
 ];
+const AERO_V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, int24 tickSpacing) view returns (address pool)',
+];
 const V3_POOL_ABI = ['function fee() view returns (uint24)'];
 const AERO_FACTORY_ABI = [
     'function getPool(address tokenA, address tokenB, bool stable) view returns (address)',
@@ -260,7 +263,9 @@ export default class PoolHelper {
                 }
             }
             else {
-                const factory = connect(factoryAddress, V3_FACTORY_ABI, this.provider);
+                const factory = dex.kind === 'aerodrome'
+                    ? connect(factoryAddress, AERO_V3_FACTORY_ABI, this.provider)
+                    : connect(factoryAddress, V3_FACTORY_ABI, this.provider);
                 await Promise.all(dex.feeTiers.map(async (feeTier) => {
                     try {
                         const poolAddress = await factory.getPool(token, weth, feeTier);
@@ -491,6 +496,7 @@ export default class PoolHelper {
                     amountToSend: inputAmount,
                     amountQuoted: lastAmount(amounts, exchangeFactory),
                     initialTollAmount: swapFee,
+                    outputTollE3: 0n,
                     slippage,
                     buildSwap: (amountToReceive) => {
                         const data = {
@@ -522,6 +528,7 @@ export default class PoolHelper {
                 amountToSend: inputAmount,
                 amountQuoted: lastAmount(amounts, exchangeFactory),
                 initialTollAmount: swapFee,
+                outputTollE3: 0n,
                 slippage,
                 buildSwap: (amountToReceive) => {
                     const data = {
@@ -585,6 +592,7 @@ export default class PoolHelper {
             amountToSend: inputAmount,
             amountQuoted: amountOut,
             initialTollAmount: swapFee,
+            outputTollE3: 0n,
             slippage,
             buildSwap: (amountToReceive) => {
                 const data = {

package/dist/router/types.d.ts

@@ -40,6 +40,8 @@ export type V3PathHop = {
     tokenIn: string;
     tokenOut: string;
     fee: string;
+    currentFee?: string | number;
+    tickSpacing?: string | number;
 };
 export type V3Path = V3PathHop[];
 export type CachedPath = {

package/dist/router/velora.d.ts

@@ -14,6 +14,7 @@ interface V3DexEntry {
 interface VeloraDexConfig {
     UniswapV2?: V2DexEntry;
     AerodromeV2?: V2DexEntry;
+    AerodromeV3?: V3DexEntry;
     PancakeSwapV2?: V2DexEntry;
     UniswapV3?: V3DexEntry;
     PancakeSwapV3?: V3DexEntry;
@@ -29,6 +30,7 @@ export interface GetRouteFromPathParams {
     dex: SupportedDex;
     cachedPath: CachedPath;
     amountIn: bigint;
+    tollIn: boolean;
     toll: {
         currency: string;
         amount: bigint;
@@ -39,5 +41,5 @@ export interface GetRouteFromPathParams {
     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 declare function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, tollIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }: GetRouteFromPathParams): Promise<Route>;
 export {};

package/dist/router/velora.js

@@ -1,6 +1,6 @@
 import { Contract, solidityPacked } from 'ethers';
 import { TOLL_DIVISOR_20BPS } from '../constants.js';
-import { AerodromeV2Adapter__factory, IPancakeQuoterV2__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, UniswapV4Adapter__factory, } from '../typechain/index.js';
+import { AerodromeV3Adapter__factory, AerodromeV2Adapter__factory, IPancakeQuoterV2__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, UniswapV4Adapter__factory, } from '../typechain/index.js';
 import { connectV4Quoter, toAdapterPathKeys } from './getUniswapV4Route.js';
 import { SWAP_DEADLINE_SECONDS } from './constants.js';
 import { finalizeRouteQuote } from './finalizeRoute.js';
@@ -10,12 +10,18 @@ const V2_ROUTER_ABI = [
 const AERO_V2_ROUTER_ABI = [
     'function getAmountsOut(uint256 amountIn, (address from, address to, bool stable, address factory)[] routes) external view returns (uint256[] amounts)',
 ];
+const AERO_V3_QUOTER_ABI = [
+    'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, int24 tickSpacing, uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+];
 function connectV2Router(address, provider) {
     return new Contract(address, V2_ROUTER_ABI, provider);
 }
 function connectAeroV2Router(address, provider) {
     return new Contract(address, AERO_V2_ROUTER_ABI, provider);
 }
+function connectAeroV3Quoter(address, provider) {
+    return new Contract(address, AERO_V3_QUOTER_ABI, provider);
+}
 function connectV3Quoter(address, provider) {
     return IPancakeQuoterV2__factory.connect(address, provider);
 }
@@ -33,6 +39,12 @@ export function buildVeloraDexConfig(addresses) {
             routerAddress: addresses.routers.aerodromeV2,
         };
     }
+    if (addresses.adapters.aerodromeV3 && addresses.quoters.aerodromeV3) {
+        cfg.AerodromeV3 = {
+            adapter: addresses.adapters.aerodromeV3,
+            quoterAddress: addresses.quoters.aerodromeV3,
+        };
+    }
     if (addresses.adapters.pancakeV2 && addresses.routers.pancakeV2) {
         cfg.PancakeSwapV2 = {
             adapter: addresses.adapters.pancakeV2,
@@ -71,7 +83,7 @@ function encodeV3Path(path) {
     }
     return solidityPacked(pathEncoding, pathToEncode);
 }
-export async function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }) {
+export async function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, tollIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }) {
     if (!cachedPath) {
         throw new Error('No cached path');
     }
@@ -95,7 +107,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -128,6 +140,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -163,7 +176,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -196,6 +209,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -212,6 +226,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 effectiveSlippageBps,
             };
         }
+        case 'AerodromeV3':
         case 'PancakeSwapV3':
         case 'UniswapV3': {
             if (cachedPath.type !== 'v3') {
@@ -222,15 +237,43 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 throw new Error(`DEX ${dex} not supported on chainId ${chainId}`);
             }
             const adapter = entry.adapter;
-            const quoter = connectV3Quoter(entry.quoterAddress, provider);
-            const encodedPath = encodeV3Path(cachedPath.path);
-            const [{ amountOut: grossAmountToReceive }, blockNumber] = await Promise.all([
-                quoter.quoteExactInput.staticCall(encodedPath, amountIn),
-                provider.getBlockNumber(),
-            ]);
+            let encodedPath;
+            let grossAmountToReceive;
+            let blockNumber;
+            if (dex === 'AerodromeV3') {
+                if (cachedPath.path.length !== 1) {
+                    throw new Error('Aerodrome V3 multi-hop not supported');
+                }
+                const [hop] = cachedPath.path;
+                const tickSpacing = BigInt(hop.fee);
+                encodedPath = solidityPacked(['address', 'uint24', 'address'], [hop.tokenIn, Number(tickSpacing), hop.tokenOut]);
+                const quoter = connectAeroV3Quoter(entry.quoterAddress, provider);
+                const [quote, currentBlockNumber] = await Promise.all([
+                    quoter.quoteExactInputSingle.staticCall({
+                        tokenIn: hop.tokenIn,
+                        tokenOut: hop.tokenOut,
+                        amountIn,
+                        tickSpacing,
+                        sqrtPriceLimitX96: 0n,
+                    }),
+                    provider.getBlockNumber(),
+                ]);
+                grossAmountToReceive = quote.amountOut;
+                blockNumber = currentBlockNumber;
+            }
+            else {
+                const quoter = connectV3Quoter(entry.quoterAddress, provider);
+                encodedPath = encodeV3Path(cachedPath.path);
+                const [quote, currentBlockNumber] = await Promise.all([
+                    quoter.quoteExactInput.staticCall(encodedPath, amountIn),
+                    provider.getBlockNumber(),
+                ]);
+                grossAmountToReceive = quote.amountOut;
+                blockNumber = currentBlockNumber;
+            }
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -238,7 +281,10 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend += toll.amount;
             }
             const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
-            const buildCallDataForAmount = (amountToReceive) => UniswapV3Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+            const swapInterface = dex === 'AerodromeV3'
+                ? AerodromeV3Adapter__factory.createInterface()
+                : UniswapV3Adapter__factory.createInterface();
+            const buildCallDataForAmount = (amountToReceive) => swapInterface.encodeFunctionData('executeSwap', [
                 {
                     amountToSend,
                     amountToReceive,
@@ -263,6 +309,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -301,7 +348,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -335,6 +382,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {

package/package.json

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