@guru-fund/sdk 0.2.1 → 0.2.3

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", "PancakeSwapV2", "PancakeSwapV3"];
+export declare const SUPPORTED_DEXS: readonly ["UniswapV2", "UniswapV3", "UniswapV4", "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',
+    'AerodromeV2',
     'PancakeSwapV2',
     'PancakeSwapV3',
 ];

package/dist/router/getFallbackRoutes.js

@@ -2,6 +2,42 @@ 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 tryDirectAerodromeV2RouteIn(poolHelper, { tokenIn, tokenOut, amountIn, slippage, finalization, }) {
+    const factory = poolHelper.addresses.factories.aerodromeV2;
+    if (!factory || !poolHelper.addresses.adapters.aerodromeV2)
+        return null;
+    try {
+        const route = await poolHelper.getStableForTokenQuote({
+            path: [tokenIn, tokenOut],
+            inputAmount: amountIn,
+            slippage,
+            exchangeFactory: factory,
+            finalization,
+        });
+        return { ...route, hops: 1 };
+    }
+    catch {
+        return null;
+    }
+}
+async function tryDirectAerodromeV2RouteOut(poolHelper, { tokenIn, tokenOut, amountIn, slippage, finalization, }) {
+    const factory = poolHelper.addresses.factories.aerodromeV2;
+    if (!factory || !poolHelper.addresses.adapters.aerodromeV2)
+        return null;
+    try {
+        const route = await poolHelper.getTokensForStableQuote({
+            path: [tokenIn, tokenOut],
+            inputAmount: amountIn,
+            slippage,
+            exchangeFactory: factory,
+            finalization,
+        });
+        return { ...route, hops: 1 };
+    }
+    catch {
+        return null;
+    }
+}
 export async function getFallbackRouteIn(params, ctx) {
     const { chainId, tokenIn, tokenOut, amountIn, slippageE2 } = params;
     const slippage = BigInt(slippageE2 ?? 500) * 10n;
@@ -34,6 +70,15 @@ export async function getFallbackRouteIn(params, ctx) {
             finalization,
         });
     }
+    const directAerodrome = await tryDirectAerodromeV2RouteIn(poolHelper, {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage,
+        finalization,
+    });
+    if (directAerodrome)
+        return directAerodrome;
     const pool = await poolHelper.getUniswapCompatibleTokenPool(tokenOut);
     const path = [tokenIn, weth, tokenOut];
     const route = await poolHelper.getStableForTokenQuote({
@@ -78,6 +123,15 @@ export async function getFallbackRouteOut(params, ctx) {
         });
         return { ...route, hops: 1 };
     }
+    const directAerodrome = await tryDirectAerodromeV2RouteOut(poolHelper, {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage,
+        finalization,
+    });
+    if (directAerodrome)
+        return directAerodrome;
     const pool = await poolHelper.getUniswapCompatibleTokenPool(tokenIn);
     const path = [tokenIn, weth, tokenOut];
     const route = await poolHelper.getTokensForStableQuote({

package/dist/router/index.js

@@ -65,26 +65,44 @@ export async function getRouteOut(params, ctx) {
 }
 export async function getPriceUsd1e18(token, ctx) {
     const addresses = getGuruProtocolAddresses(ctx.chainId);
+    if (compareAddresses(token, addresses.tokens.USDC) ||
+        compareAddresses(token, addresses.tokens.USDT)) {
+        return 10n ** 18n;
+    }
     const poolHelper = new PoolHelper({
         chainId: ctx.chainId,
         provider: ctx.provider,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     });
-    const { amount: wethUsdt } = await poolHelper.getBestQuote({
-        tokenAmount: parseEther('1'),
-        path: [addresses.tokens.WETH, addresses.tokens.USDT],
-        requireSwappable: false,
-    });
-    const wethUsd = wethUsdt * 10n ** 12n;
+    const stable = addresses.tokens.USDC;
+    const { decimals: stableDecimals } = await new Token(stable, ctx.provider)
+        .metadata()
+        .catch(() => ({ decimals: 6 }));
+    const stableUnit = Token.unitFor(stableDecimals);
+    const stableAmountToUsd1e18 = (amount) => (amount * 10n ** 18n) / stableUnit;
+    let wethUsdCache;
+    const getWethUsd = async () => {
+        if (wethUsdCache != null)
+            return wethUsdCache;
+        const { amount: wethStable } = await poolHelper.getBestQuote({
+            tokenAmount: parseEther('1'),
+            path: [addresses.tokens.WETH, stable],
+            requireSwappable: false,
+        });
+        wethUsdCache = stableAmountToUsd1e18(wethStable);
+        return wethUsdCache;
+    };
     if (compareAddresses(token, addresses.tokens.WETH)) {
-        return wethUsd;
+        return getWethUsd();
     }
-    const { decimals } = await new Token(token, ctx.provider)
-        .metadata()
-        .catch(() => ({ decimals: 0 }));
+    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 WETH_UNIT = 10n ** 18n;
     try {
+        const wethUsd = await getWethUsd();
         const { amount: oneTokenInWeth } = await poolHelper.getBestQuote({
             tokenAmount: oneToken,
             path: [token, addresses.tokens.WETH],
@@ -93,13 +111,32 @@ export async function getPriceUsd1e18(token, ctx) {
         return (oneTokenInWeth * wethUsd) / WETH_UNIT;
     }
     catch (error) {
-        const v4Usd = await _priceViaV4Pools(token, oneToken, wethUsd, ctx);
+        const v4Usd = await _priceViaV4Pools(token, oneToken, getWethUsd, ctx);
         if (v4Usd !== null)
             return v4Usd;
         throw error;
     }
 }
-async function _priceViaV4Pools(token, oneToken, wethUsd, ctx) {
+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)
+        return null;
+    return (amountToReceive * 10n ** 18n) / Token.unitFor(stableDecimals);
+}
+async function _priceViaV4Pools(token, oneToken, getWethUsd, ctx) {
     const addresses = getGuruProtocolAddresses(ctx.chainId);
     const quoterAddress = addresses.quoters.uniswapV4;
     if (!quoterAddress)
@@ -129,6 +166,7 @@ async function _priceViaV4Pools(token, oneToken, wethUsd, ctx) {
     }
     const inWeth = await quoteVia(addresses.tokens.WETH);
     if (inWeth !== null) {
+        const wethUsd = await getWethUsd();
         return (inWeth * wethUsd) / WETH_UNIT;
     }
     return null;

package/dist/router/pathCache.js

@@ -4,6 +4,21 @@ export function extractPathFromResponse(dex, response) {
     if (dex === 'UniswapV4') {
         return extractV4Path(response);
     }
+    if (dex === 'AerodromeV2') {
+        const v2Response = response;
+        const exchange = v2Response.priceRoute.bestRoute[0].swaps[0].swapExchanges[0];
+        const path = exchange.data.path;
+        if (!Array.isArray(path) || typeof path[0] !== 'string') {
+            throw new Error('Unexpected Aerodrome V2 path structure');
+        }
+        const routes = path.slice(0, -1).map((from, i) => ({
+            from,
+            to: path[i + 1],
+            stable: Boolean(exchange.data.pools?.[i]?.stable),
+            factory: exchange.data.factory,
+        }));
+        return { type: 'aerodromeV2', path, routes, hops: path.length - 1 };
+    }
     if (dex === 'UniswapV2' || dex === 'PancakeSwapV2') {
         const v2Response = response;
         const path = v2Response.priceRoute.bestRoute[0].swaps[0].swapExchanges[0]

package/dist/router/poolHelper.d.ts

@@ -61,7 +61,7 @@ type VersionSpecificQuoteRequest = Omit<QuoteRequest, 'path' | 'slippage'> & {
     poolAddress?: string;
 };
 export type StableQuoteRequest = {
-    path: [string, string, string];
+    path: [string, string] | [string, string, string];
     inputAmount: bigint;
     slippage: bigint;
     exchangeFactory: string;

package/dist/router/poolHelper.js

@@ -547,20 +547,24 @@ export default class PoolHelper {
         const quoter = dexData.kind === 'aerodrome'
             ? connect(dexData.quoter, AERO_V3_QUOTER_ABI, this.provider)
             : IPancakeQuoterV2__factory.connect(dexData.quoter, this.provider);
+        const [stable, intermediate, token] = path;
+        if (!token) {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: direct V3 fallback not supported (factory=${exchangeFactory})`);
+        }
         const { feeTier: stableFeeTier } = await this.getUniswapCompatibleTokenPool(path[0], {
             exchangeFactory,
         });
-        const { feeTier: tokenFeeTier } = await this.getUniswapCompatibleTokenPool(path[2], {
+        const { feeTier: tokenFeeTier } = await this.getUniswapCompatibleTokenPool(token, {
             exchangeFactory,
         });
-        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [path[0], stableFeeTier, path[1], tokenFeeTier, path[2]]);
+        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [stable, stableFeeTier, intermediate, tokenFeeTier, token]);
         if (dexData.kind === 'aerodrome') {
             throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: Aerodrome V3 multi-hop not supported (factory=${exchangeFactory})`);
         }
         const univ3Quoter = quoter;
         const amountOut = await this._quoteV3MultiHop(univ3Quoter, adjustedInputAmount, pathBytes, [
-            { tokenIn: path[0], tokenOut: path[1], fee: stableFeeTier },
-            { tokenIn: path[1], tokenOut: path[2], fee: tokenFeeTier },
+            { tokenIn: stable, tokenOut: intermediate, fee: stableFeeTier },
+            { tokenIn: intermediate, tokenOut: token, fee: tokenFeeTier },
         ]);
         const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
         const finalized = await this._finalizeExecutableQuote({
@@ -568,13 +572,13 @@ export default class PoolHelper {
             adapter,
             path: [
                 {
-                    tokenIn: path[0],
-                    tokenOut: path[1],
+                    tokenIn: stable,
+                    tokenOut: intermediate,
                     fee: String(stableFeeTier),
                 },
                 {
-                    tokenIn: path[1],
-                    tokenOut: path[2],
+                    tokenIn: intermediate,
+                    tokenOut: token,
                     fee: String(tokenFeeTier),
                 },
             ],
@@ -662,7 +666,10 @@ export default class PoolHelper {
                     adapter,
                     data: finalized.data,
                     callData: finalized.callData,
-                    toll: { currency: path[2], amount: finalized.tollAmount },
+                    toll: {
+                        currency: path[path.length - 1],
+                        amount: finalized.tollAmount,
+                    },
                     effectiveSlippageBps: finalized.effectiveSlippageBps,
                 };
             }
@@ -697,7 +704,10 @@ export default class PoolHelper {
                 adapter,
                 data: finalized.data,
                 callData: finalized.callData,
-                toll: { currency: path[2], amount: finalized.tollAmount },
+                toll: {
+                    currency: path[path.length - 1],
+                    amount: finalized.tollAmount,
+                },
                 effectiveSlippageBps: finalized.effectiveSlippageBps,
             };
         }
@@ -705,16 +715,20 @@ export default class PoolHelper {
             throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: Aerodrome V3 multi-hop not supported (factory=${exchangeFactory})`);
         }
         const v3Quoter = IPancakeQuoterV2__factory.connect(dexData.quoter, this.provider);
+        const [token, intermediate, stable] = path;
+        if (!stable) {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: direct V3 fallback not supported (factory=${exchangeFactory})`);
+        }
         const { feeTier: tokenFeeTier } = await this.getUniswapCompatibleTokenPool(path[0], {
             exchangeFactory,
         });
-        const { feeTier: stableFeeTier } = await this.getUniswapCompatibleTokenPool(path[2], {
+        const { feeTier: stableFeeTier } = await this.getUniswapCompatibleTokenPool(stable, {
             exchangeFactory,
         });
-        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [path[0], tokenFeeTier, path[1], stableFeeTier, path[2]]);
+        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [token, tokenFeeTier, intermediate, stableFeeTier, stable]);
         const amountOut = await this._quoteV3MultiHop(v3Quoter, inputAmount, pathBytes, [
-            { tokenIn: path[0], tokenOut: path[1], fee: tokenFeeTier },
-            { tokenIn: path[1], tokenOut: path[2], fee: stableFeeTier },
+            { tokenIn: token, tokenOut: intermediate, fee: tokenFeeTier },
+            { tokenIn: intermediate, tokenOut: stable, fee: stableFeeTier },
         ]);
         const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
         const netAmountOut = amountOut - (amountOut * swapFeePercentage) / PERCENT_DENOMINATOR;
@@ -723,13 +737,13 @@ export default class PoolHelper {
             adapter,
             path: [
                 {
-                    tokenIn: path[0],
-                    tokenOut: path[1],
+                    tokenIn: token,
+                    tokenOut: intermediate,
                     fee: String(tokenFeeTier),
                 },
                 {
-                    tokenIn: path[1],
-                    tokenOut: path[2],
+                    tokenIn: intermediate,
+                    tokenOut: stable,
                     fee: String(stableFeeTier),
                 },
             ],
@@ -755,7 +769,7 @@ export default class PoolHelper {
             adapter,
             data: finalized.data,
             callData: finalized.callData,
-            toll: { currency: path[2], amount: finalized.tollAmount },
+            toll: { currency: stable, amount: finalized.tollAmount },
             effectiveSlippageBps: finalized.effectiveSlippageBps,
         };
     }

package/dist/router/types.d.ts

@@ -5,6 +5,12 @@ import type { SwapV4Struct } from '../typechain/out/UniswapV4Adapter';
 import type { GuruProtocolChainId } from '../addresses';
 import type { PrefixTx } from './simulation';
 export type V2Path = string[];
+export type AeroV2Route = {
+    from: string;
+    to: string;
+    stable: boolean;
+    factory: string;
+};
 export type V4PathHop = {
     tokenIn: string;
     tokenOut: string;
@@ -40,6 +46,11 @@ export type CachedPath = {
     type: 'v2';
     path: V2Path;
     hops: number;
+} | {
+    type: 'aerodromeV2';
+    path: V2Path;
+    routes: AeroV2Route[];
+    hops: number;
 } | {
     type: 'v3';
     path: V3Path;
@@ -121,6 +132,14 @@ export interface VeloraDataV2 {
     feeFactor: number;
     gasUSD: string;
 }
+export interface VeloraDataAerodromeV2 extends VeloraDataV2 {
+    pools?: {
+        stable?: boolean;
+        address?: string;
+        fee?: number;
+        direction?: boolean;
+    }[];
+}
 export interface VeloraDataV3 {
     path: V3PathHop[];
     gasUSD: string;
@@ -145,5 +164,6 @@ export interface VeloraDataV4 {
     gasUSD?: string;
 }
 export type VeloraRouteResponseV2 = VeloraRouteResponse<VeloraDataV2>;
+export type VeloraRouteResponseAerodromeV2 = VeloraRouteResponse<VeloraDataAerodromeV2>;
 export type VeloraRouteResponseV3 = VeloraRouteResponse<VeloraDataV3>;
 export type VeloraRouteResponseV4 = VeloraRouteResponse<VeloraDataV4>;

package/dist/router/velora.d.ts

@@ -13,6 +13,7 @@ interface V3DexEntry {
 }
 interface VeloraDexConfig {
     UniswapV2?: V2DexEntry;
+    AerodromeV2?: V2DexEntry;
     PancakeSwapV2?: V2DexEntry;
     UniswapV3?: V3DexEntry;
     PancakeSwapV3?: V3DexEntry;

package/dist/router/velora.js

@@ -1,15 +1,21 @@
 import { Contract, solidityPacked } from 'ethers';
 import { TOLL_DIVISOR_20BPS } from '../constants.js';
-import { IPancakeQuoterV2__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, UniswapV4Adapter__factory, } from '../typechain/index.js';
+import { 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';
 const V2_ROUTER_ABI = [
     'function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts)',
 ];
+const AERO_V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, (address from, address to, bool stable, address factory)[] routes) external view returns (uint256[] amounts)',
+];
 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 connectV3Quoter(address, provider) {
     return IPancakeQuoterV2__factory.connect(address, provider);
 }
@@ -21,6 +27,12 @@ export function buildVeloraDexConfig(addresses) {
             routerAddress: addresses.routers.uniswapV2,
         };
     }
+    if (addresses.adapters.aerodromeV2 && addresses.routers.aerodromeV2) {
+        cfg.AerodromeV2 = {
+            adapter: addresses.adapters.aerodromeV2,
+            routerAddress: addresses.routers.aerodromeV2,
+        };
+    }
     if (addresses.adapters.pancakeV2 && addresses.routers.pancakeV2) {
         cfg.PancakeSwapV2 = {
             adapter: addresses.adapters.pancakeV2,
@@ -65,6 +77,73 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
     }
     const dexConfig = buildVeloraDexConfig(addresses);
     switch (dex) {
+        case 'AerodromeV2': {
+            if (cachedPath.type !== 'aerodromeV2') {
+                throw new Error('Expected Aerodrome V2 path');
+            }
+            const entry = dexConfig[dex];
+            if (!entry) {
+                throw new Error(`DEX ${dex} not supported on chainId ${chainId}`);
+            }
+            const router = connectAeroV2Router(entry.routerAddress, provider);
+            const adapter = entry.adapter;
+            const [grossAmountToReceive, blockNumber] = await Promise.all([
+                router
+                    .getAmountsOut(amountIn, cachedPath.routes)
+                    .then((amounts) => amounts.at(-1)),
+                provider.getBlockNumber(),
+            ]);
+            let amountQuoted = grossAmountToReceive;
+            let amountToSend = amountIn;
+            if (toll.amount === 0n) {
+                toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
+            else {
+                amountToSend += toll.amount;
+            }
+            const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
+            const buildCallDataForAmount = (amountToReceive) => AerodromeV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+                {
+                    amountToSend,
+                    amountToReceive,
+                    routes: cachedPath.routes,
+                    deadline,
+                },
+            ]);
+            const context = {
+                chainId,
+                blockNumber,
+                controller,
+                vault,
+                adapter,
+                account,
+                path: cachedPath.path,
+                buildCallDataForAmount,
+                simulator,
+                prefixTxs,
+            };
+            const { finalAmountToReceive, callData, effectiveSlippageBps, finalTollAmount, } = await finalizeRouteQuote({
+                context,
+                amountToSend,
+                amountQuoted,
+                initialTollAmount: toll.amount,
+                maxSlippageE3,
+            });
+            return {
+                adapter,
+                data: {
+                    amountToSend,
+                    amountToReceive: finalAmountToReceive,
+                    routes: cachedPath.routes,
+                    deadline,
+                },
+                callData,
+                toll: { ...toll, amount: finalTollAmount },
+                hops: cachedPath.hops,
+                effectiveSlippageBps,
+            };
+        }
         case 'PancakeSwapV2':
         case 'UniswapV2': {
             if (cachedPath.type !== 'v2') {

package/package.json

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