@guru-fund/sdk 0.2.8 → 0.2.10

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

@@ -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

@@ -23,6 +23,7 @@ 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[];

package/dist/router/v4PoolDiscovery.js

@@ -66,18 +66,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 +187,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,10 +195,16 @@ 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
         ? []

package/package.json

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