@guru-fund/sdk 0.2.7 → 0.2.9

package/dist/router/constants.d.ts

@@ -16,3 +16,4 @@ export declare const V4_ZERO_ADDRESS = "0x00000000000000000000000000000000000000
 export declare const DEXSCREENER_ENDPOINT = "https://api.dexscreener.com/token-pairs/v1";
 export declare const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10000;
 export declare const V4_DISCOVERY_MAX_POOLS = 3;
+export declare const V4_DISCOVERY_MAX_LP_FEE = 100000;

package/dist/router/constants.js

@@ -25,3 +25,4 @@ export const V4_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 export const DEXSCREENER_ENDPOINT = 'https://api.dexscreener.com/token-pairs/v1';
 export const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10_000;
 export const V4_DISCOVERY_MAX_POOLS = 3;
+export const V4_DISCOVERY_MAX_LP_FEE = 100_000;

package/dist/router/index.d.ts

@@ -10,6 +10,7 @@ export interface RouterContext {
     getPath: PathFetcher;
 }
 export declare function veloraThenV4Discovery(velora: () => Promise<Route>, v4Discovery: () => Promise<Route>): Promise<Route>;
+export declare function bestOfV4AndFallback(v4Discovery: () => Promise<Route>, fallback: () => Promise<Route>): Promise<Route>;
 export declare function tryWithVeloraFallback<T>(velora: () => Promise<T>, fallback: () => Promise<T>): Promise<T>;
 export declare function getRouteIn(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;
 export declare function getRouteOut(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;

package/dist/router/index.js

@@ -43,6 +43,29 @@ export async function veloraThenV4Discovery(velora, v4Discovery) {
         return await v4Discovery();
     }
 }
+export async function bestOfV4AndFallback(v4Discovery, fallback) {
+    const [v4Result, fallbackResult] = await Promise.allSettled([
+        v4Discovery(),
+        fallback(),
+    ]);
+    if (v4Result.status === 'rejected' &&
+        v4Result.reason instanceof Error &&
+        (v4Result.reason.message.includes('TOKEN_LOCKED_BY_V4_HOOK') ||
+            v4Result.reason.message.includes('UNISWAP_V4_HOOK_ROUTE_REVERTED'))) {
+        throw v4Result.reason;
+    }
+    if (v4Result.status === 'fulfilled' && fallbackResult.status === 'fulfilled') {
+        return BigInt(v4Result.value.data.amountToReceive) >=
+            BigInt(fallbackResult.value.data.amountToReceive)
+            ? v4Result.value
+            : fallbackResult.value;
+    }
+    if (v4Result.status === 'fulfilled')
+        return v4Result.value;
+    if (fallbackResult.status === 'fulfilled')
+        return fallbackResult.value;
+    throw fallbackResult.reason;
+}
 export async function tryWithVeloraFallback(velora, fallback) {
     try {
         return await velora();
@@ -72,7 +95,12 @@ export async function getRouteIn(params, ctx) {
         simulator: ctx.simulator,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     };
-    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteIn(params, fallbackCtx));
+    try {
+        return await getVeloraRoute(params, veloraCtx);
+    }
+    catch {
+        return bestOfV4AndFallback(() => getUniswapV4Route(params, v4Ctx), () => getFallbackRouteIn(params, fallbackCtx));
+    }
 }
 export async function getRouteOut(params, ctx) {
     const veloraCtx = {
@@ -89,7 +117,12 @@ export async function getRouteOut(params, ctx) {
         simulator: ctx.simulator,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     };
-    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteOut(params, fallbackCtx));
+    try {
+        return await getVeloraRoute(params, veloraCtx);
+    }
+    catch {
+        return bestOfV4AndFallback(() => getUniswapV4Route(params, v4Ctx), () => getFallbackRouteOut(params, fallbackCtx));
+    }
 }
 export async function getPriceUsd1e18(token, ctx) {
     const addresses = getGuruProtocolAddresses(ctx.chainId);

package/dist/router/poolHelper.d.ts

@@ -36,7 +36,9 @@ export type Pool = {
     feeTier: FeeTier;
     exchangeFactory: string;
     wethBalance: bigint;
+    activeLiquidity?: bigint;
 };
+export declare function rankUsablePools(pools: Pool[]): Pool[];
 type Quote = {
     feeTier: FeeTier;
     amount: bigint;

package/dist/router/poolHelper.js

@@ -24,7 +24,10 @@ const V3_FACTORY_ABI = [
 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 V3_POOL_ABI = [
+    'function fee() view returns (uint24)',
+    'function liquidity() view returns (uint128)',
+];
 const AERO_FACTORY_ABI = [
     'function getPool(address tokenA, address tokenB, bool stable) view returns (address)',
 ];
@@ -114,6 +117,17 @@ function buildDexTable(addresses) {
     }
     return table;
 }
+export function rankUsablePools(pools) {
+    return pools
+        .filter((pool) => pool.feeTier === 0 || (pool.activeLiquidity ?? 0n) > 0n)
+        .sort((a, b) => {
+        if (a.wethBalance > b.wethBalance)
+            return -1;
+        if (a.wethBalance < b.wethBalance)
+            return 1;
+        return 0;
+    });
+}
 const PERCENT_DENOMINATOR = 100000n;
 const CACHE_DURATION = 60 * 60 * 1000;
 function withSlippageTolerance(amount, slippage) {
@@ -274,11 +288,14 @@ export default class PoolHelper {
                         const wethBalance = await wethToken.balanceOf(poolAddress);
                         if (wethBalance === 0n)
                             return;
+                        const pool = connect(poolAddress, V3_POOL_ABI, this.provider);
+                        const activeLiquidity = await pool.liquidity();
                         pools.push({
                             address: poolAddress,
                             feeTier: feeTier,
                             exchangeFactory: factoryAddress,
                             wethBalance,
+                            activeLiquidity,
                         });
                     }
                     catch {
@@ -286,14 +303,7 @@ export default class PoolHelper {
                 }));
             }
         }));
-        pools.sort((a, b) => {
-            if (a.wethBalance > b.wethBalance)
-                return -1;
-            if (a.wethBalance < b.wethBalance)
-                return 1;
-            return 0;
-        });
-        return pools;
+        return rankUsablePools(pools);
     }
     async getUniswapCompatibleTokenPools(token, options) {
         const swappableOnly = options?.swappableOnly ?? true;

package/dist/router/v4PoolDiscovery.d.ts

@@ -8,6 +8,7 @@ export interface V4PoolKey {
     tickSpacing: number;
     hooks: string;
 }
+export declare function isSafeDiscoveredV4PoolKey(key: V4PoolKey): boolean;
 export declare function computeV4PoolId(key: V4PoolKey): string;
 interface DexscreenerPair {
     dexId?: string;

package/dist/router/v4PoolDiscovery.js

@@ -1,7 +1,7 @@
 import { AbiCoder, keccak256, zeroPadValue, } from 'ethers';
 import { getGuruProtocolAddresses, } from '../addresses.js';
 import compareAddresses from '../helpers/compareAddresses.js';
-import { DEXSCREENER_ENDPOINT, V4_ZERO_ADDRESS, V4_DISCOVERY_MAX_POOLS, V4_DISCOVERY_MIN_LIQUIDITY_USD, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, } from './constants.js';
+import { DEXSCREENER_ENDPOINT, V4_ZERO_ADDRESS, V4_DISCOVERY_MAX_POOLS, V4_DISCOVERY_MAX_LP_FEE, V4_DISCOVERY_MIN_LIQUIDITY_USD, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, } from './constants.js';
 const V4_CHAIN_CONFIG = {
     1: {
         dexscreenerSlug: 'ethereum',
@@ -20,6 +20,9 @@ const V4_CHAIN_CONFIG = {
     },
 };
 const POOL_INITIALIZE_TOPIC = '0xdd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438';
+export function isSafeDiscoveredV4PoolKey(key) {
+    return key.fee >= 0 && key.fee <= V4_DISCOVERY_MAX_LP_FEE;
+}
 export function computeV4PoolId(key) {
     return keccak256(AbiCoder.defaultAbiCoder().encode(['address', 'address', 'uint24', 'int24', 'address'], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
 }
@@ -150,7 +153,7 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
             break;
     }
     const keys = await Promise.all(poolIds.map((poolId) => resolvePoolKey(chainId, poolId, provider)));
-    const resolvedKeys = keys.filter((key) => key !== null);
+    const resolvedKeys = keys.filter((key) => key !== null && isSafeDiscoveredV4PoolKey(key));
     const onchainKeys = resolvedKeys.length > 0
         ? []
         : await discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider);
@@ -187,7 +190,7 @@ async function discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provi
     });
     return logs
         .map(poolKeyFromInitializeLog)
-        .filter((key) => key !== null)
+        .filter((key) => key !== null && isSafeDiscoveredV4PoolKey(key))
         .sort((a, b) => a.fee - b.fee);
 }
 export function _clearV4DiscoveryCache() {

package/package.json

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