@steerprotocol/liquidity-meter 1.0.0 → 2.0.4

package/src/depth.js

@@ -0,0 +1,492 @@
+/* eslint-disable no-bitwise */
+
+// Market-depth bands for a Uniswap v3 pool snapshot.
+// Dependency-free, uses BigInt for exact fixed-point arithmetic (Q64.96).
+
+/////////////////////////// Fixed-point + constants ///////////////////////////
+
+const Q32 = 1n << 32n;
+const Q96 = 1n << 96n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+
+const MIN_TICK = -887272;
+const MAX_TICK = 887272;
+const MIN_SQRT_RATIO = 4295128739n; // ~ TickMath.MIN_SQRT_RATIO
+const MAX_SQRT_RATIO =
+  1461446703485210103287273052203988822378723970342n; // ~ TickMath.MAX_SQRT_RATIO
+
+function mulDiv(a, b, d) {
+  return (a * b) / d;
+}
+function mulDivRoundingUp(a, b, d) {
+  const prod = a * b;
+  const q = prod / d;
+  return prod % d === 0n ? q : q + 1n;
+}
+
+//////////////////////////// TickMath (v3 exact) //////////////////////////////
+
+// getSqrtRatioAtTick — direct port of UniswapV3 TickMath.getSqrtRatioAtTick
+// Returns Q64.96 sqrt price at the LOWER boundary of `tick`.
+export function getSqrtRatioAtTick(tick) {
+  if (tick < MIN_TICK || tick > MAX_TICK) throw new Error("TICK_OUT_OF_RANGE");
+
+  let absTick = tick < 0 ? -tick : tick;
+
+  // 1.0001^(2^i) constants in Q128.128
+  let ratio =
+    (absTick & 0x1) !== 0
+      ? 0xfffcb933bd6fad37aa2d162d1a594001n
+      : 0x100000000000000000000000000000000n;
+  if ((absTick & 0x2) !== 0)
+    ratio = (ratio * 0xfff97272373d413259a46990580e213an) >> 128n;
+  if ((absTick & 0x4) !== 0)
+    ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn) >> 128n;
+  if ((absTick & 0x8) !== 0)
+    ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n) >> 128n;
+  if ((absTick & 0x10) !== 0)
+    ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n) >> 128n;
+  if ((absTick & 0x20) !== 0)
+    ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n) >> 128n;
+  if ((absTick & 0x40) !== 0)
+    ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n) >> 128n;
+  if ((absTick & 0x80) !== 0)
+    ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n) >> 128n;
+  if ((absTick & 0x100) !== 0)
+    ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n) >> 128n;
+  if ((absTick & 0x200) !== 0)
+    ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n) >> 128n;
+  if ((absTick & 0x400) !== 0)
+    ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n) >> 128n;
+  if ((absTick & 0x800) !== 0)
+    ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n) >> 128n;
+  if ((absTick & 0x1000) !== 0)
+    ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n) >> 128n;
+  if ((absTick & 0x2000) !== 0)
+    ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n) >> 128n;
+  if ((absTick & 0x4000) !== 0)
+    ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n) >> 128n;
+  if ((absTick & 0x8000) !== 0)
+    ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n) >> 128n;
+  if ((absTick & 0x10000) !== 0)
+    ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n) >> 128n;
+  if ((absTick & 0x20000) !== 0)
+    ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n) >> 128n;
+  if ((absTick & 0x40000) !== 0)
+    ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n) >> 128n;
+  if ((absTick & 0x80000) !== 0)
+    ratio = (ratio * 0x48a170391f7dc42444e8fa2n) >> 128n;
+
+  if (tick > 0) {
+    ratio = MAX_UINT256 / ratio;
+  }
+
+  // round up to guarantee that getTickAtSqrtRatio(sqrtRatioAtTick(tick)) == tick
+  const sqrtPriceX96 = (ratio >> 32n) + (ratio % Q32 === 0n ? 0n : 1n);
+  return sqrtPriceX96;
+}
+
+//////////////////////////// Amount delta helpers /////////////////////////////
+
+// Token1 amount for price move from sqrtA -> sqrtB (A < B), no fee. Q64.96
+// amount1 = L * (sqrtB - sqrtA) / Q96
+function amount1DeltaUp(sqrtA, sqrtB, liquidity, roundUp = true) {
+  if (sqrtB < sqrtA) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  const num = liquidity * (sqrtB - sqrtA);
+  return roundUp ? mulDivRoundingUp(num, 1n, Q96) : mulDiv(num, 1n, Q96);
+}
+
+// Token0 amount for price move from sqrtA -> sqrtB (A < B), no fee.
+// amount0 = L * (sqrtB - sqrtA) * Q96 / (sqrtB * sqrtA)
+// For downward price move (sell), call with (lower, upper) = (target, current).
+function amount0DeltaDown(sqrtA, sqrtB, liquidity, roundUp = true) {
+  if (sqrtB < sqrtA) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  const num = liquidity * (sqrtB - sqrtA) * Q96;
+  const den = sqrtB * sqrtA;
+  return roundUp ? mulDivRoundingUp(num, 1n, den) : mulDiv(num, 1n, den);
+}
+
+// Gross-up an input amount to include Uniswap fee (feePips in 1e6 units).
+function grossUpForFee(amountIn, feePips) {
+  if (!feePips) return amountIn;
+  const feeDen = 1_000_000n;
+  const den = feeDen - BigInt(feePips);
+  return mulDivRoundingUp(amountIn, feeDen, den);
+}
+
+//////////////////////////// Utilities ////////////////////////////////////////
+
+function toUSDFromRaw(amount, decimals, usd) {
+  if (!usd || usd <= 0) return 0;
+  const scale = 10n ** BigInt(Math.max(0, decimals));
+  const usdMicros = BigInt(Math.round(usd * 1e6));
+  const micros = (amount * usdMicros) / scale; // BigInt of USD microdollars
+  return Number(micros) / 1e6;
+}
+
+function clamp(val, lo, hi) {
+  return Math.max(lo, Math.min(hi, val));
+}
+
+// Binary search helpers on pre-sorted initialized ticks
+function firstTickIndexGreaterThan(ticks, t) {
+  let lo = 0,
+    hi = ticks.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (ticks[mid].index <= t) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo; // first index with ticks[i].index > t (may be ticks.length)
+}
+function lastTickIndexAtOrBelow(ticks, t) {
+  const i = firstTickIndexGreaterThan(ticks, t) - 1;
+  return i;
+}
+
+//////////////////////////// Core: integrate to targets ///////////////////////
+
+// Convert a percent move (e.g., +2%) to an approximate tick delta.
+// 1 tick ~= 0.01% in price -> but we use exact log(1.0001)
+function percentToTickDelta(pct) {
+  const r = 1 + pct / 100; // price multiplier
+  const delta = Math.log(r) / Math.log(1.0001);
+  // round toward nearest integer (small effect; bucketed charts are tolerant)
+  return Math.max(1, Math.round(delta));
+}
+
+// Integrate upward (price ↑): token1 in to move sqrtPrice to target
+function integrateUp(
+  sqrtStart,
+  currentTick,
+  Lstart,
+  targetTick,
+  feePips,
+  ticks
+) {
+  let s = sqrtStart;
+  let L = Lstart;
+  let tick = currentTick;
+
+  let i = firstTickIndexGreaterThan(ticks, tick); // first initialized tick above current
+  let targetSqrt = getSqrtRatioAtTick(clamp(targetTick, MIN_TICK, MAX_TICK));
+  let acc = 0n;
+
+  while (s < targetSqrt) {
+    const nextTick = i < 0 || i >= ticks.length ? null : ticks[i];
+    const sqrtAtNext = nextTick ? getSqrtRatioAtTick(nextTick.index) : MAX_SQRT_RATIO;
+    const bound = sqrtAtNext < targetSqrt ? sqrtAtNext : targetSqrt;
+
+    // token1 in over [s, bound]
+    const dy = amount1DeltaUp(s, bound, L, true);
+    const dyGross = grossUpForFee(dy, feePips);
+    acc += dyGross;
+    s = bound;
+
+    if (s === sqrtAtNext && nextTick) {
+      // crossing upward → add liquidityNet
+      L = L + nextTick.liquidityNet;
+      tick = nextTick.index;
+      i += 1;
+    } else {
+      break; // hit target
+    }
+  }
+
+  return { token1In: acc, finalSqrt: s, finalTick: tick, finalL: L };
+}
+
+// Integrate downward (price ↓): token0 in to move sqrtPrice to target
+function integrateDown(
+  sqrtStart,
+  currentTick,
+  Lstart,
+  targetTick,
+  feePips,
+  ticks
+) {
+  let s = sqrtStart;
+  let L = Lstart;
+  let tick = currentTick;
+
+  let j = lastTickIndexAtOrBelow(ticks, tick); // initialized tick at/below current
+  let targetSqrt = getSqrtRatioAtTick(clamp(targetTick, MIN_TICK, MAX_TICK));
+  let acc = 0n;
+
+  while (s > targetSqrt) {
+    const prevTick = j >= 0 ? ticks[j] : null;
+    const sqrtAtPrev = prevTick ? getSqrtRatioAtTick(prevTick.index) : MIN_SQRT_RATIO;
+    const bound = sqrtAtPrev > targetSqrt ? sqrtAtPrev : targetSqrt;
+
+    // token0 in over [bound, s] (note lower, upper)
+    const dx = amount0DeltaDown(bound, s, L, true);
+    const dxGross = grossUpForFee(dx, feePips);
+    acc += dxGross;
+    s = bound;
+
+    if (s === sqrtAtPrev && prevTick) {
+      // crossing downward → subtract liquidityNet
+      L = L - prevTick.liquidityNet;
+      tick = prevTick.index - 1; // inside the lower tick now
+      j -= 1;
+    } else {
+      break; // hit target
+    }
+  }
+  return { token0In: acc, finalSqrt: s, finalTick: tick, finalL: L };
+}
+
+//////////////////////////// Public API //////////////////////////////////////
+
+// Compute stacked depth bands for ±{1,2,5,10}% (defaults) at a snapshot.
+export function computeMarketDepthBands(params) {
+  const {
+    sqrtPriceX96,
+    tick,
+    liquidity,
+    feePips = 0,
+    ticks,
+    token0,
+    token1,
+    percentBuckets = [1, 2, 5, 10],
+  } = params;
+
+  // safety: ensure ticks sorted asc
+  const sortedTicks = [...ticks].sort((a, b) => a.index - b.index);
+
+  // Build target ticks for each bucket
+  const upTargets = percentBuckets.map((p) =>
+    clamp(tick + percentToTickDelta(p), MIN_TICK, MAX_TICK)
+  );
+  const downTargets = percentBuckets.map((p) =>
+    clamp(tick - percentToTickDelta(p), MIN_TICK, MAX_TICK)
+  );
+
+  // Integrate cumulatively to each target
+  const buyCumToken1 = [];
+  const sellCumToken0 = [];
+
+  // Upward cumulative
+  let sU = sqrtPriceX96;
+  let tU = tick;
+  let LU = liquidity;
+  for (const tgt of upTargets) {
+    const { token1In, finalSqrt, finalTick, finalL } = integrateUp(
+      sU,
+      tU,
+      LU,
+      tgt,
+      feePips,
+      sortedTicks
+    );
+    const cum = (buyCumToken1.length ? buyCumToken1[buyCumToken1.length - 1] : 0n) + token1In;
+    buyCumToken1.push(cum);
+    sU = finalSqrt;
+    tU = finalTick;
+    LU = finalL;
+  }
+
+  // Downward cumulative
+  let sD = sqrtPriceX96;
+  let tD = tick;
+  let LD = liquidity;
+  for (const tgt of downTargets) {
+    const { token0In, finalSqrt, finalTick, finalL } = integrateDown(
+      sD,
+      tD,
+      LD,
+      tgt,
+      feePips,
+      sortedTicks
+    );
+    const cum = (sellCumToken0.length ? sellCumToken0[sellCumToken0.length - 1] : 0n) + token0In;
+    sellCumToken0.push(cum);
+    sD = finalSqrt;
+    tD = finalTick;
+    LD = finalL;
+  }
+
+  // Convert to USD notionals using input token for each side
+  const buyCumUSD = buyCumToken1.map((a) =>
+    toUSDFromRaw(a, token1.decimals, token1.usdPrice)
+  );
+  const sellCumUSD = sellCumToken0.map((a) =>
+    toUSDFromRaw(a, token0.decimals, token0.usdPrice)
+  );
+
+  // Stacked bands (diffs of cumulative)
+  const toBands = (cum) => [
+    cum[0],
+    cum[1] - cum[0],
+    cum[2] - cum[1],
+    cum[3] - cum[2],
+  ];
+
+  const buyBandsUSD = toBands(buyCumUSD);
+  const sellBandsUSD = toBands(sellCumUSD);
+
+  // Headline +/− 2%
+  const idx2 = percentBuckets.findIndex((p) => p === 2);
+  const depthPlus2USD = idx2 >= 0 ? buyCumUSD[idx2] : NaN;
+  const depthMinus2USD = idx2 >= 0 ? sellCumUSD[idx2] : NaN;
+
+  return {
+    buyCumUSD,
+    sellCumUSD,
+    buyBandsUSD,
+    sellBandsUSD,
+    depthPlus2USD,
+    depthMinus2USD,
+    buyCumToken1,
+    sellCumToken0,
+  };
+}
+
+export const DepthInternals = {
+  MIN_TICK,
+  MAX_TICK,
+};
+
+//////////////////////////// Price impact by size /////////////////////////////
+
+function integrateUpByAmount(
+  sqrtStart,
+  currentTick,
+  Lstart,
+  budgetGross, // token1 gross in
+  feePips,
+  ticks
+) {
+  let s = sqrtStart;
+  let L = Lstart;
+  let tick = currentTick;
+  let i = firstTickIndexGreaterThan(ticks, tick);
+  const feeDen = 1_000_000n;
+  const den = feeDen - BigInt(feePips || 0);
+
+  while (budgetGross > 0n && s < MAX_SQRT_RATIO) {
+    const nextTick = i < 0 || i >= ticks.length ? null : ticks[i];
+    const sqrtAtNext = nextTick ? getSqrtRatioAtTick(nextTick.index) : MAX_SQRT_RATIO;
+
+    const dyNetToNext = amount1DeltaUp(s, sqrtAtNext, L, true);
+    const dyGrossToNext = grossUpForFee(dyNetToNext, feePips || 0);
+
+    if (budgetGross < dyGrossToNext) {
+      // Partial step within this segment. Compute net from gross, then delta sqrt.
+      const netIn = mulDiv(budgetGross, den, feeDen);
+      const deltaS = mulDivRoundingUp(netIn, Q96, L);
+      s = s + deltaS;
+      budgetGross = 0n;
+      break;
+    } else {
+      budgetGross -= dyGrossToNext;
+      s = sqrtAtNext;
+      if (nextTick) {
+        L = L + nextTick.liquidityNet;
+        tick = nextTick.index;
+        i += 1;
+      }
+    }
+  }
+  return { finalSqrt: s, finalTick: tick, finalL: L };
+}
+
+function integrateDownByAmount(
+  sqrtStart,
+  currentTick,
+  Lstart,
+  budgetGross, // token0 gross in
+  feePips,
+  ticks
+) {
+  let s = sqrtStart;
+  let L = Lstart;
+  let tick = currentTick;
+  let j = lastTickIndexAtOrBelow(ticks, tick);
+  const feeDen = 1_000_000n;
+  const den = feeDen - BigInt(feePips || 0);
+
+  while (budgetGross > 0n && s > MIN_SQRT_RATIO) {
+    const prevTick = j >= 0 ? ticks[j] : null;
+    const sqrtAtPrev = prevTick ? getSqrtRatioAtTick(prevTick.index) : MIN_SQRT_RATIO;
+
+    const dxNetToPrev = amount0DeltaDown(sqrtAtPrev, s, L, true);
+    const dxGrossToPrev = grossUpForFee(dxNetToPrev, feePips || 0);
+
+    if (budgetGross < dxGrossToPrev) {
+      // Partial step within this segment. Solve bound:
+      // bound = s * L*Q96 / (L*Q96 + netIn*s)
+      const netIn = mulDiv(budgetGross, den, feeDen);
+      const LQ = L * Q96;
+      const num = LQ * s;
+      const den2 = LQ + netIn * s;
+      const bound = den2 === 0n ? MIN_SQRT_RATIO : mulDiv(num, 1n, den2);
+      s = bound;
+      budgetGross = 0n;
+      break;
+    } else {
+      budgetGross -= dxGrossToPrev;
+      s = sqrtAtPrev;
+      if (prevTick) {
+        L = L - prevTick.liquidityNet;
+        tick = prevTick.index - 1;
+        j -= 1;
+      }
+    }
+  }
+  return { finalSqrt: s, finalTick: tick, finalL: L };
+}
+
+function priceImpactPercent(startSqrt, endSqrt) {
+  // percent = ((b^2 - a^2)/a^2) * 100 = ((b-a)(b+a)/a^2)*100
+  const a = startSqrt;
+  const b = endSqrt;
+  const scale = 1_000_000n; // 1e6 -> return percent with 6 decimals as float
+  const numRaw = (b - a) * (b + a) * 100n * scale;
+  const den = a * a;
+  // signed rounding toward nearest
+  let val;
+  if (numRaw >= 0n) val = (numRaw + den / 2n) / den;
+  else val = -((-numRaw + den / 2n) / den);
+  return Number(val) / Number(scale);
+}
+
+export function computePriceImpactsBySizes({
+  sqrtPriceX96,
+  tick,
+  liquidity,
+  feePips = 0,
+  ticks,
+  buySizesToken1, // bigint[] gross token1 (buy/up)
+  sellSizesToken0, // bigint[] gross token0 (sell/down)
+}) {
+  const sortedTicks = [...ticks].sort((a, b) => a.index - b.index);
+
+  const buyPct = [];
+  for (const size of buySizesToken1) {
+    const { finalSqrt } = integrateUpByAmount(
+      sqrtPriceX96,
+      tick,
+      liquidity,
+      size,
+      feePips,
+      sortedTicks
+    );
+    buyPct.push(priceImpactPercent(sqrtPriceX96, finalSqrt));
+  }
+
+  const sellPct = [];
+  for (const size of sellSizesToken0) {
+    const { finalSqrt } = integrateDownByAmount(
+      sqrtPriceX96,
+      tick,
+      liquidity,
+      size,
+      feePips,
+      sortedTicks
+    );
+    sellPct.push(priceImpactPercent(sqrtPriceX96, finalSqrt));
+  }
+
+  return { buyPct, sellPct };
+}

package/src/index.js

@@ -0,0 +1,6 @@
+export {
+  computeMarketDepthBands,
+  computePriceImpactsBySizes,
+  getSqrtRatioAtTick,
+  DepthInternals,
+} from './depth.js';

package/src/prices.js

@@ -0,0 +1,188 @@
+import axios from 'axios';
+import { createPublicClient, http } from 'viem';
+
+function norm(addr) {
+  return addr.toLowerCase();
+}
+
+function dexSlugFromChainId(chainId) {
+  switch (Number(chainId)) {
+    case 1: return 'ethereum';
+    case 10: return 'optimism';
+    case 56: return 'bsc';
+    case 137: return 'polygon';
+    case 8453: return 'base';
+    case 42161: return 'arbitrum';
+    case 43114: return 'avalanche';
+    case 100: return 'gnosis';
+    case 324: return 'zksync';
+    case 1101: return 'polygon-zkevm';
+    default: return undefined;
+  }
+}
+
+export async function fetchPricesLlama(addresses) {
+  const uniq = Array.from(new Set(addresses.map(norm)));
+  if (!uniq.length) return {};
+  const coinsParam = uniq.map((a) => `ethereum:${a}`).join(',');
+  const url = `https://coins.llama.fi/prices/current/${coinsParam}`;
+  const res = await axios.get(url, { timeout: 8000, maxRedirects: 3 });
+  const coins = res.data?.coins || {};
+  const out = {};
+  for (const a of uniq) {
+    const key = `ethereum:${a}`;
+    const p = coins[key]?.price;
+    if (typeof p === 'number' && Number.isFinite(p)) out[a] = p;
+  }
+  return out;
+}
+
+export async function fetchPricesCoingecko(addresses, apiKey) {
+  const uniq = Array.from(new Set(addresses.map(norm)));
+  if (!uniq.length) return {};
+  const url = 'https://api.coingecko.com/api/v3/simple/token_price/ethereum';
+  const params = {
+    contract_addresses: uniq.join(','),
+    vs_currencies: 'usd',
+  };
+  const headers = apiKey ? { 'x-cg-pro-api-key': apiKey } : undefined;
+  const res = await axios.get(url, { params, headers, timeout: 8000, maxRedirects: 3 });
+  const body = res.data || {};
+  const out = {};
+  for (const a of uniq) {
+    const ent = body[a];
+    const p = ent?.usd;
+    if (typeof p === 'number' && Number.isFinite(p)) out[a] = p;
+  }
+  return out;
+}
+
+export async function fetchTokenUSDPrices({ addresses, source = 'auto', rpcUrl, chainId, debug = false, reserveLimit = 100 }) {
+  const uniq = Array.from(new Set(addresses.map(norm)));
+  const byAddress = {};
+  const coingeckoKey = process.env.COINGECKO_API_KEY;
+  const envRpc = rpcUrl || process.env.RPC_URL;
+
+  async function resolveChainId(rpcUrl) {
+    try {
+      if (!rpcUrl) return undefined;
+      const client = createPublicClient({ transport: http(rpcUrl) });
+      return await client.getChainId();
+    } catch (_) {
+      return undefined;
+    }
+  }
+
+  async function fetchPricesReserve({ addresses, chainId, limit = 100 }) {
+    if (!chainId) return {};
+    const url = `https://api.reserve.org/discover/dtf`;
+    const params = { chainId, limit };
+    const res = await axios.get(url, { params, timeout: 8000, maxRedirects: 3 });
+    const arr = Array.isArray(res.data) ? res.data : [];
+    const out = {};
+    const set = new Set(addresses.map(norm));
+    for (const ent of arr) {
+      const addr = norm(ent.address || '');
+      if (set.has(addr)) {
+        const p = Number(ent.price);
+        if (Number.isFinite(p)) out[addr] = p;
+      }
+    }
+    if (debug) {
+      // eslint-disable-next-line no-console
+      console.error(`[prices] reserve: chainId=${chainId} limit=${limit} returned=${arr.length} matched=${Object.keys(out).length}`);
+    }
+    return out;
+  }
+
+  async function fetchPricesDexscreener({ addresses, chainId }) {
+    if (!chainId) return {};
+    const slug = dexSlugFromChainId(chainId);
+    if (!slug) return {};
+    const out = {};
+    for (const addr of addresses.map(norm)) {
+      try {
+        const url = `https://api.dexscreener.com/token-pairs/v1/${slug}/${addr}`;
+        const res = await axios.get(url, { timeout: 8000, maxRedirects: 3 });
+        const arr = Array.isArray(res.data) ? res.data : [];
+        // choose entry where token is baseToken; pick highest liquidity.usd
+        let best = null;
+        for (const ent of arr) {
+          const base = norm(ent?.baseToken?.address || '');
+          if (base !== addr) continue;
+          const liq = Number(ent?.liquidity?.usd ?? 0);
+          if (!best || liq > (Number(best?.liquidity?.usd ?? 0))) best = ent;
+        }
+        if (best) {
+          const p = Number(best.priceUsd);
+          if (Number.isFinite(p)) out[addr] = p;
+          if (debug) {
+            // eslint-disable-next-line no-console
+            console.error(`[prices] dexscreener: addr=${addr} pairs=${arr.length} bestLiq=${best?.liquidity?.usd ?? 0} priceUsd=${best?.priceUsd ?? 'n/a'}`);
+          }
+        } else if (debug) {
+          // eslint-disable-next-line no-console
+          console.error(`[prices] dexscreener: addr=${addr} no baseToken match in ${arr.length} pairs`);
+        }
+      } catch (e) {
+        if (debug) {
+          // eslint-disable-next-line no-console
+          console.error(`[prices] dexscreener error for ${addr}: ${e?.message || e}`);
+        }
+      }
+    }
+    return out;
+  }
+
+  async function tryLlama() {
+    try {
+      const p = await fetchPricesLlama(uniq);
+      for (const k of Object.keys(p)) if (byAddress[k] == null) byAddress[k] = { price: p[k], source: 'llama' };
+      return Object.keys(p).length > 0;
+    } catch (_) { return false; }
+  }
+  async function tryReserve(chainId) {
+    try {
+      if (!chainId) return false;
+      const p = await fetchPricesReserve({ addresses: uniq, chainId, limit: reserveLimit });
+      for (const k of Object.keys(p)) if (byAddress[k] == null) byAddress[k] = { price: p[k], source: 'reserve' };
+      return Object.keys(p).length > 0;
+    } catch (_) { return false; }
+  }
+  async function tryDex(chainId) {
+    try {
+      if (!chainId) return false;
+      const p = await fetchPricesDexscreener({ addresses: uniq, chainId });
+      for (const k of Object.keys(p)) if (byAddress[k] == null) byAddress[k] = { price: p[k], source: 'dexscreener' };
+      return Object.keys(p).length > 0;
+    } catch (_) { return false; }
+  }
+  async function tryCG() {
+    try {
+      const p = await fetchPricesCoingecko(uniq, coingeckoKey);
+      for (const k of Object.keys(p)) if (byAddress[k] == null) byAddress[k] = { price: p[k], source: 'coingecko' };
+      return Object.keys(p).length > 0;
+    } catch (_) { return false; }
+  }
+
+  // Resolve chainId if needed for reserve/dexscreener
+  let cid = chainId;
+  if (!cid && (source === 'reserve' || source === 'dexscreener' || source === 'auto')) cid = await resolveChainId(envRpc);
+  if (debug) {
+    // eslint-disable-next-line no-console
+    console.error(`[prices] source=${source} rpc=${envRpc ? 'yes' : 'no'} chainId=${cid ?? 'n/a'} addresses=${uniq.length}`);
+  }
+
+  if (source === 'reserve') await tryReserve(cid);
+  else if (source === 'dexscreener') await tryDex(cid);
+  else if (source === 'llama') await tryLlama();
+  else if (source === 'coingecko') await tryCG();
+  else {
+    // auto: try reserve (if chainId), then dexscreener (if chainId), then llama, then CG
+    await tryReserve(cid);
+    await tryDex(cid);
+    await tryLlama();
+    await tryCG();
+  }
+  return { byAddress };
+}