@guru-fund/sdk 0.2.3 → 0.2.4

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/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);

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;

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,
@@ -212,6 +224,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 effectiveSlippageBps,
             };
         }
+        case 'AerodromeV3':
         case 'PancakeSwapV3':
         case 'UniswapV3': {
             if (cachedPath.type !== 'v3') {
@@ -222,12 +235,40 @@ 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) {
@@ -238,7 +279,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,

package/package.json

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