@steerprotocol/liquidity-meter 1.0.0 → 2.0.4

package/bin/liquidity-depth.js

@@ -0,0 +1,795 @@
+#!/usr/bin/env node
+
+// CLI for computing Uniswap v3 market depth bands with real data
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createPublicClient, parseAbi, getAddress, http as viemHttp } from 'viem';
+import {
+  analyzePool,
+  findBlockNumbersForTimestamps,
+  formatTimestampUTC,
+  parseDurationArg,
+  parsePercentBuckets,
+  parseTimestampArg,
+  resolveAnalysisBlockContext,
+} from '../src/api.js';
+import { createForkClient, simulateVaultWithdraw, resolveViemChain } from '../src/withdraw.js';
+
+const UNISWAP_V3_FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+const FACTORY_ABI = parseAbi([
+  'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address)'
+]);
+
+function parseArgs(argv) {
+  const args = {
+    percent: '1,2,5,10',
+    subgraph: undefined,
+    source: 'tevm',
+    rpc: process.env.RPC_URL,
+    usdSizes: '1000,5000,10000,25000,50000,100000',
+    prices: process.env.PRICES_SOURCE || 'auto',
+    reserveLimit: Number(process.env.RESERVE_LIMIT) || 100,
+    csv: undefined,
+    outdir: 'reports',
+    // withdraw simulation
+    vault: undefined,
+    owner: process.env.OWNER,
+    withdrawPct: undefined,
+    withdrawShares: undefined,
+    block: undefined,
+    timestamp: undefined,
+    timeStart: undefined,
+    timeEnd: undefined,
+    timeInterval: undefined,
+    timeWindow: undefined,
+    timeCount: undefined,
+  };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--pool' || a === '-p') args.pool = argv[++i];
+    else if (a === '--percent' || a === '-b') args.percent = argv[++i];
+    else if (a === '--subgraph' || a === '-s') args.subgraph = argv[++i];
+    else if (a === '--rpc' || a === '-r') args.rpc = argv[++i];
+    else if (a === '--source') args.source = argv[++i]; // tevm|subgraph|auto
+    else if (a === '--token0-usd') args.token0USD = Number(argv[++i]);
+    else if (a === '--token1-usd') args.token1USD = Number(argv[++i]);
+    else if (a === '--assume-stable') args.assumeStable = Number(argv[++i]); // 0 or 1
+    else if (a === '--usd-sizes') args.usdSizes = argv[++i];
+    else if (a === '--prices') args.prices = argv[++i]; // llama|coingecko|auto
+    // withdraw simulation flags
+    else if (a === '--vault') args.vault = argv[++i];
+    else if (a === '--owner') args.owner = argv[++i];
+    else if (a === '--withdraw-pct' || a === '--withdraw-percent') args.withdrawPct = Number(argv[++i]);
+    else if (a === '--withdraw-shares') args.withdrawShares = argv[++i];
+    else if (a === '--block') args.block = argv[++i];
+    else if (a === '--timestamp' || a === '--time') args.timestamp = argv[++i];
+    else if (a === '--time-start') args.timeStart = argv[++i];
+    else if (a === '--time-end') args.timeEnd = argv[++i];
+    else if (a === '--time-interval') args.timeInterval = argv[++i];
+    else if (a === '--time-window') args.timeWindow = argv[++i];
+    else if (a === '--time-count') args.timeCount = Number(argv[++i]);
+    else if (a === '--debug') args.debug = true;
+    else if (a === '--csv') args.csv = argv[++i];
+    else if (a === '--outdir') args.outdir = argv[++i];
+    else if (a === '--reserve-limit') args.reserveLimit = Number(argv[++i]);
+    else if (a === '--json' || a === '-j') args.json = true;
+    else if (a === '--help' || a === '-h') args.help = true;
+    else if (a === '--version' || a === '-v') args.version = true;
+    else if (!args.pool && /^0x[0-9a-fA-F]{40}$/.test(a)) args.pool = a;
+    else {
+      console.error(`Unknown arg: ${a}`);
+      args.help = true;
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+liquidity-depth — Uniswap v3 market depth bands
+
+Usage:
+  liquidity-depth --pool <POOL_ADDRESS> [--percent 1,2,5,10] [--source tevm|viem|subgraph|auto] [--rpc <URL>] [--block N] [--timestamp ISO|SECONDS]
+                 [--time-start ISO|SECONDS] [--time-end ISO|SECONDS] [--time-interval 1h] [--time-window 7d] [--time-count N]
+                 [--token0-usd N] [--token1-usd N] [--usd-sizes 1000,5000,...] [--json]
+  liquidity-depth --pool <POOL_ADDRESS> --vault <VAULT_ADDRESS> --owner <OWNER_ADDRESS> [--withdraw-pct N | --withdraw-shares <SHARES>] [same options]
+  liquidity-depth --csv <FILE.csv> [--outdir reports] [same options as above]
+
+Options:
+  -p, --pool       Uniswap v3 pool address (e.g., 0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8)
+  -b, --percent    Percent buckets, comma-separated (default: 1,2,5,10)
+  -s, --subgraph   Subgraph URL (default: Uniswap v3 mainnet)
+      --source     Data source: tevm|viem|subgraph|auto (default: tevm)
+  -r, --rpc        RPC URL (for on-chain fetching via tevm fork). Also reads RPC_URL env var
+      --token0-usd Override token0 USD price
+      --token1-usd Override token1 USD price
+      --assume-stable 0|1  Assume token index is $1 stable (fills missing USD)
+      --usd-sizes   Comma-separated USD sizes for price impact (default: 1000,5000,10000,25000,50000,100000)
+      --block       Fork/query state at the specified block number
+      --timestamp   Resolve a historical block by timestamp (seconds or ISO-8601); requires --rpc
+      --time-start  Beginning timestamp (inclusive) for time-series mode (seconds or ISO-8601)
+      --time-end    Ending timestamp (inclusive, default: now) for time-series mode
+      --time-interval  Step between snapshots in time-series mode (e.g., 1h, 30m; default: 1h)
+      --time-window    How far back from --time-end to start when --time-start omitted (e.g., 7d)
+      --time-count     Number of intervals to fetch (e.g., 168 for 7 days hourly); implies backwards from --time-end
+      --prices      Price source: reserve|dexscreener|llama|coingecko|auto (default: auto; env PRICES_SOURCE)
+      --reserve-limit  N  Limit for Reserve API (default: 100; env RESERVE_LIMIT)
+      --debug       Print debug logs to stderr for pricing/inference
+      --csv         CSV file with a header including a 'pool' or 'address' column
+      --outdir      Output directory for per-pool reports (default: reports)
+      --vault       Steer vault address (to simulate withdrawal)
+      --owner       Owner address whose shares are withdrawn (also reads OWNER env)
+      --withdraw-pct    Percent of owner's shares to withdraw (e.g., 25)
+      --withdraw-shares Raw share amount to withdraw (overrides --withdraw-pct)
+  -j, --json       Output machine-readable JSON
+  -h, --help       Show help
+  -v, --version    Show version
+`);
+}
+
+function looksLikeAddress(x) {
+  return typeof x === 'string' && /^0x[0-9a-fA-F]{40}$/.test(x.trim());
+}
+function extractFirstAddress(x) {
+  if (typeof x !== 'string') return undefined;
+  const m = x.match(/0x[0-9a-fA-F]{40}/);
+  return m ? m[0] : undefined;
+}
+function normKey(k) {
+  return String(k || '').toLowerCase().replace(/[ _-]+/g, '');
+}
+
+// Minimal CSV parser: returns array of row objects keyed by header.
+// Supports commas, quoted fields with double-quotes escaping.
+function parseCSV(content) {
+  const outRows = [];
+  let i = 0;
+  const len = content.length;
+  const fields = [];
+  function readLine() {
+    fields.length = 0;
+    let field = '';
+    let inQuotes = false;
+    let sawAny = false;
+    while (i < len) {
+      const ch = content[i++];
+      if (!inQuotes && (ch === '\n' || ch === '\r')) {
+        if (ch === '\r' && content[i] === '\n') i++; // CRLF
+        fields.push(field);
+        return true;
+      }
+      if (ch === '"') {
+        if (inQuotes) {
+          if (content[i] === '"') { field += '"'; i++; }
+          else { inQuotes = false; }
+        } else {
+          inQuotes = true;
+          sawAny = true;
+        }
+      } else if (ch === ',' && !inQuotes) {
+        fields.push(field);
+        field = '';
+        sawAny = true;
+      } else {
+        field += ch;
+        sawAny = true;
+      }
+    }
+    if (!sawAny && field === '') return false; // EOF after last newline
+    fields.push(field);
+    return true;
+  }
+  // read header
+  if (!readLine()) return [];
+  const header = fields.map((h) => h.trim());
+  while (readLine()) {
+    const obj = {};
+    for (let j = 0; j < header.length; j++) obj[header[j]] = (fields[j] ?? '').trim();
+    outRows.push(obj);
+  }
+  return outRows;
+}
+
+async function runBatch(args) {
+  const csvPath = args.csv;
+  const outdir = args.outdir || 'reports';
+  const data = await fs.readFile(csvPath, 'utf8');
+  const rows = parseCSV(data);
+  if (!rows.length) {
+    console.error('CSV is empty or could not be parsed. Expect a header row with a pool/address column.');
+    process.exit(1);
+  }
+  await fs.mkdir(outdir, { recursive: true });
+
+  const pick = (obj, names) => {
+    // try direct keys
+    for (const n of names) if (obj[n] != null && String(obj[n]).trim() !== '') return String(obj[n]).trim();
+    // try normalized keys
+    const map = Object.fromEntries(Object.keys(obj).map((k) => [normKey(k), k]));
+    for (const n of names) {
+      const key = map[normKey(n)];
+      if (key && obj[key] != null && String(obj[key]).trim() !== '') return String(obj[key]).trim();
+    }
+    return undefined;
+  };
+
+  function parseFeeToUint24(v) {
+    if (v == null) return undefined;
+    const s = String(v).trim();
+    if (!s) return undefined;
+    // raw number like 500, 3000, 10000
+    if (/^\d+$/.test(s)) {
+      const n = Number(s);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+    // like 30bps or 5 bps
+    const mBps = s.match(/([0-9]+(?:\.[0-9]+)?)\s*bps/i);
+    if (mBps) {
+      const n = Number(mBps[1]);
+      if (Number.isFinite(n)) return Math.round(n * 100);
+    }
+    // like 0.3% or 1 %
+    const mPct = s.match(/([0-9]+(?:\.[0-9]+)?)\s*%/);
+    if (mPct) {
+      const n = Number(mPct[1]);
+      if (Number.isFinite(n)) return Math.round(n * 1e4);
+    }
+    return undefined;
+  }
+
+  async function resolvePoolFromTokens(row, rpcUrl) {
+    // attempt to find token addresses + fee
+    let t0 = pick(row, ['token0', 'token0_address', 'token 0', 'token 0 address', 'tokenA', 'base']);
+    let t1 = pick(row, ['token1', 'token1_address', 'token 1', 'token 1 address', 'tokenB', 'quote']);
+    let fee = pick(row, ['fee', 'fee_tier', 'fee tier', 'feebps']);
+
+    // If not found, scan all values for first two distinct addresses
+    if (!looksLikeAddress(t0 || '') || !looksLikeAddress(t1 || '')) {
+      const found = [];
+      for (const v of Object.values(row)) {
+        const addr = extractFirstAddress(String(v || ''));
+        if (addr && !found.includes(addr)) found.push(addr);
+        if (found.length >= 2) break;
+      }
+      if (!looksLikeAddress(t0 || '') && found[0]) t0 = found[0];
+      if (!looksLikeAddress(t1 || '') && found[1]) t1 = found[1];
+    }
+
+    // parse fee
+    const feeNum = parseFeeToUint24(fee);
+    if (!looksLikeAddress(t0 || '') || !looksLikeAddress(t1 || '') || !feeNum) return undefined;
+    if (!rpcUrl) return undefined;
+
+    const client = createPublicClient({ transport: viemHttp(rpcUrl) });
+    try {
+      const pool = await client.readContract({ address: UNISWAP_V3_FACTORY, abi: FACTORY_ABI, functionName: 'getPool', args: [getAddress(t0), getAddress(t1), feeNum] });
+      if (pool && pool !== '0x0000000000000000000000000000000000000000') return pool;
+    } catch (_) {
+      // ignore
+    }
+    return undefined;
+  }
+
+  for (let idx = 0; idx < rows.length; idx++) {
+    const row = rows[idx];
+    let pool = pick(row, ['pool', 'address', 'pool_address', 'id', 'Pool', 'Address', 'contract_address', 'contract address', 'pair_address', 'pair address']);
+    if (!looksLikeAddress(pool || '')) {
+      // try extract from any cell (e.g., Etherscan/Uniswap URL)
+      for (const v of Object.values(row)) {
+        const found = extractFirstAddress(String(v || ''));
+        if (found) { pool = found; break; }
+      }
+    }
+    if (!looksLikeAddress(pool || '')) {
+      // try factory lookup using tokens + fee
+      const viaFactory = await resolvePoolFromTokens(row, args.rpc);
+      if (viaFactory) pool = viaFactory;
+    }
+    if (!looksLikeAddress(pool || '')) {
+      console.warn(`Row ${idx + 1}: skipping (no valid pool address)`);
+      continue;
+    }
+
+    const rowArgs = {
+      ...args,
+      pool,
+      rpc: pick(row, ['rpc', 'RPC', 'rpc_url', 'RPC_URL']) || args.rpc,
+      source: pick(row, ['source', 'Source']) || args.source,
+      percent: pick(row, ['percent', 'Percents', 'buckets']) || args.percent,
+      block: pick(row, ['block', 'Block', 'block_number', 'block number']) || args.block,
+      timestamp: pick(row, ['timestamp', 'Timestamp', 'time', 'Time']) || args.timestamp,
+      token0USD: pick(row, ['token0_usd', 'token0-usd', 'token0USD']) != null ? Number(pick(row, ['token0_usd', 'token0-usd', 'token0USD'])) : args.token0USD,
+      token1USD: pick(row, ['token1_usd', 'token1-usd', 'token1USD']) != null ? Number(pick(row, ['token1_usd', 'token1-usd', 'token1USD'])) : args.token1USD,
+      usdSizes: pick(row, ['usd_sizes', 'usd-sizes', 'usdSizes']) || args.usdSizes,
+      assumeStable: pick(row, ['assume_stable', 'assume-stable', 'assumeStable']) != null ? Number(pick(row, ['assume_stable', 'assume-stable', 'assumeStable'])) : args.assumeStable,
+      prices: pick(row, ['prices', 'Prices']) || args.prices,
+      vault: pick(row, ['vault', 'Vault', 'vault_address', 'VaultAddress', 'vault address', 'strategy']) || args.vault,
+      owner: pick(row, ['owner', 'Owner', 'owner_address', 'owner address', 'withdraw_owner', 'withdraw owner', 'account', 'user', 'recipient', 'to']) || args.owner,
+      withdrawPct: pick(row, ['withdraw_pct', 'withdraw-pct', 'withdraw percent', 'withdraw_percent', 'withdrawPercentage', 'withdrawPercent', 'pct_withdraw', 'percent_withdraw']) != null ? Number(pick(row, ['withdraw_pct', 'withdraw-pct', 'withdraw percent', 'withdraw_percent', 'withdrawPercentage', 'withdrawPercent', 'pct_withdraw', 'percent_withdraw'])) : args.withdrawPct,
+      withdrawShares: pick(row, ['withdraw_shares', 'withdraw-shares', 'withdraw shares', 'withdrawShares', 'shares_to_withdraw', 'withdraw_share_amount']) || args.withdrawShares,
+    };
+
+    const wpct = rowArgs.withdrawPct;
+    const wshares = rowArgs.withdrawShares;
+    const vault = rowArgs.vault;
+    const owner = rowArgs.owner;
+
+    if (args.debug) {
+      const dbg = [];
+      if (vault) dbg.push(`vault=${vault}`);
+      if (owner) dbg.push(`owner=${owner}`);
+      if (wpct) dbg.push(`withdraw_pct=${wpct}`);
+      if (wshares) dbg.push(`withdraw_shares=${wshares}`);
+      if (dbg.length) console.error(`[batch] row ${idx + 1} overrides: ${dbg.join(' ')}`);
+    }
+
+    try {
+      const baseName = `${pool.toLowerCase()}`;
+      const file = path.join(outdir, `${baseName}.${args.json ? 'json' : 'txt'}`);
+      const output = await runSingleInvocation(rowArgs);
+      await fs.writeFile(file, output, 'utf8');
+      console.log(`Wrote: ${file}`);
+    } catch (err) {
+      const errMsg = String(err?.stack || err?.message || err);
+      const errFile = path.join(outdir, `error-${pool.toLowerCase()}.txt`);
+      await fs.writeFile(errFile, errMsg, 'utf8');
+      console.error(`Failed row ${idx + 1} (${pool}): ${err?.message || err}`);
+      console.error(`  -> see ${errFile}`);
+    }
+  }
+}
+
+async function runTimeSeries(args) {
+  if (!args.pool) {
+    console.error('Time-series mode requires --pool');
+    process.exit(1);
+  }
+  if (args.block) {
+    console.error('Time-series mode cannot be combined with --block. Use --time-start/--time-window/--time-count with --timestamp.');
+    process.exit(1);
+  }
+  if (!args.rpc) {
+    console.error('Time-series mode requires --rpc (or RPC_URL env) so timestamps can be resolved to blocks.');
+    process.exit(1);
+  }
+
+  let intervalSec;
+  try {
+    intervalSec = parseDurationArg(args.timeInterval ?? '1h');
+  } catch (e) {
+    console.error(`Invalid --time-interval value: ${e?.message || e}`);
+    process.exit(1);
+  }
+  if (intervalSec <= 0n) {
+    console.error('--time-interval must be greater than zero');
+    process.exit(1);
+  }
+
+  let endSec;
+  try {
+    endSec = args.timeEnd != null ? parseTimestampArg(args.timeEnd) : BigInt(Math.floor(Date.now() / 1000));
+  } catch (e) {
+    console.error(`Invalid --time-end value: ${e?.message || e}`);
+    process.exit(1);
+  }
+
+  let startSec;
+  if (args.timeStart != null) {
+    try {
+      startSec = parseTimestampArg(args.timeStart);
+    } catch (e) {
+      console.error(`Invalid --time-start value: ${e?.message || e}`);
+      process.exit(1);
+    }
+  }
+  if (startSec == null && args.timeWindow != null) {
+    try {
+      const windowSec = parseDurationArg(args.timeWindow);
+      startSec = endSec > windowSec ? endSec - windowSec : 0n;
+    } catch (e) {
+      console.error(`Invalid --time-window value: ${e?.message || e}`);
+      process.exit(1);
+    }
+  }
+
+  let count = undefined;
+  if (args.timeCount != null) {
+    if (!Number.isFinite(args.timeCount) || args.timeCount <= 0) {
+      console.error('--time-count must be a positive integer');
+      process.exit(1);
+    }
+    count = Math.floor(args.timeCount);
+  }
+  if (startSec == null) {
+    if (count != null) {
+      const span = intervalSec * BigInt(Math.max(count - 1, 0));
+      startSec = endSec > span ? endSec - span : 0n;
+    } else {
+      console.error('Time-series mode requires --time-start, --time-window, or --time-count');
+      process.exit(1);
+    }
+  }
+
+  if (startSec > endSec) {
+    [startSec, endSec] = [endSec, startSec];
+  }
+
+  const timestamps = [];
+  const maxPoints = 10000;
+  for (let ts = startSec; ts <= endSec; ts += intervalSec) {
+    timestamps.push(ts);
+    if (count != null && timestamps.length >= count) break;
+    if (timestamps.length > maxPoints) {
+      console.error(`Time-series would produce more than ${maxPoints} snapshots. Increase --time-interval or reduce the window/count.`);
+      process.exit(1);
+    }
+  }
+  if (!timestamps.length) timestamps.push(startSec);
+  if (count == null && timestamps[timestamps.length - 1] < endSec) {
+    timestamps.push(endSec);
+  }
+  if (count != null && timestamps.length > count) {
+    timestamps.splice(0, timestamps.length - count);
+  }
+
+  const tsStrings = timestamps.map((ts) => ts.toString());
+  if (!tsStrings.length) {
+    console.error('No timestamps resolved for time-series mode');
+    process.exit(1);
+  }
+  const resolvedBlocks = await findBlockNumbersForTimestamps({
+    rpcUrl: args.rpc,
+    timestamps,
+    debug: !!args.debug,
+  });
+
+  if (!args.json) {
+    const startIso = formatTimestampUTC(BigInt(tsStrings[0]));
+    const endIso = formatTimestampUTC(BigInt(tsStrings[tsStrings.length - 1]));
+    const intervalHuman = args.timeInterval ?? '1h';
+    console.log(`Time-series: ${tsStrings.length} snapshots from ${startIso || tsStrings[0]} to ${endIso || tsStrings[tsStrings.length - 1]} every ~${intervalHuman}`);
+  }
+
+  const jsonResults = [];
+  for (let i = 0; i < tsStrings.length; i++) {
+    const tsStr = tsStrings[i];
+    const pointArgs = {
+      ...args,
+      timestamp: undefined,
+      block: resolvedBlocks[i].toString(),
+    };
+    const label = formatTimestampUTC(BigInt(tsStr)) || tsStr;
+    if (!args.json) {
+      console.log(`\n=== ${label} (unix ${tsStr}) ===`);
+    }
+    try {
+      const output = await runSingleInvocation(pointArgs);
+      if (args.json) {
+        const text = output.trim();
+        if (text) {
+          jsonResults.push(JSON.parse(text));
+        } else {
+          jsonResults.push(null);
+        }
+      } else {
+        process.stdout.write(output);
+        if (!output.endsWith('\n')) console.log('');
+      }
+    } catch (err) {
+      console.error(`Time-series run failed for timestamp ${tsStr}: ${err?.message || err}`);
+      process.exit(1);
+    }
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify(jsonResults, null, 2));
+  }
+}
+
+function captureConsoleOutput(run) {
+  const lines = [];
+  const original = console.log;
+  console.log = (...args) => {
+    lines.push(args.join(' '));
+  };
+  try {
+    run();
+  } finally {
+    console.log = original;
+  }
+  return lines.length ? `${lines.join('\n')}\n` : '';
+}
+
+async function executeSingle(args) {
+  let percentBuckets;
+  try {
+    percentBuckets = parsePercentBuckets(args.percent);
+  } catch (e) {
+    throw new Error(`Invalid --percent value: ${e?.message || e}`);
+  }
+  if (!percentBuckets.length) {
+    throw new Error('No valid percent buckets parsed.');
+  }
+
+  const wantsWithdraw =
+    args.vault && (Number.isFinite(args.withdrawPct) || args.withdrawShares);
+  let sharedClient = null;
+  let sharedBlockTag;
+  if (wantsWithdraw) {
+    if (!args.rpc) {
+      throw new Error('Missing --rpc (or RPC_URL env) for tevm source.');
+    }
+    const blockContext = await resolveAnalysisBlockContext({
+      block: args.block,
+      timestamp: args.timestamp,
+      rpcUrl: args.rpc,
+      debug: args.debug,
+    });
+    sharedBlockTag = blockContext.blockTag;
+    sharedClient = await createForkClient({
+      rpcUrl: args.rpc,
+      blockTag: sharedBlockTag,
+    });
+  }
+
+  let before;
+  before = await analyzePool({
+    poolAddress: args.pool,
+    percentBuckets,
+    source: args.source,
+    rpcUrl: args.rpc,
+    subgraphUrl: args.subgraph,
+    token0USD: args.token0USD,
+    token1USD: args.token1USD,
+    assumeStable: args.assumeStable,
+    usdSizes: args.usdSizes,
+    prices: args.prices,
+    reserveLimit: args.reserveLimit,
+    block: args.block,
+    timestamp: args.timestamp,
+    debug: args.debug,
+    client: sharedClient,
+    blockTag: sharedBlockTag,
+  });
+
+  let after = null;
+  if (before.usedSource === 'tevm' && wantsWithdraw) {
+    const viemChain = await resolveViemChain(args.rpc);
+    await simulateVaultWithdraw({
+      client: before.client,
+      vault: args.vault,
+      owner: args.owner,
+      withdrawPct: args.withdrawPct,
+      withdrawShares: args.withdrawShares,
+      debug: !!args.debug,
+      cliPool: args.pool,
+      viemChain,
+    });
+    after = await analyzePool({
+      poolAddress: args.pool,
+      percentBuckets,
+      source: 'tevm',
+      rpcUrl: args.rpc,
+      token0USD: args.token0USD,
+      token1USD: args.token1USD,
+      assumeStable: args.assumeStable,
+      usdSizes: args.usdSizes,
+      prices: args.prices,
+      reserveLimit: args.reserveLimit,
+      debug: args.debug,
+      client: before.client,
+      blockTag: before.blockTag,
+    });
+    if (args.debug) {
+      console.error(`[after] tick: ${before.snap.tick} -> ${after.snap.tick}`);
+      console.error(
+        `[after] liquidity: ${before.snap.liquidity.toString()} -> ${after.snap.liquidity.toString()}`
+      );
+    }
+  }
+
+  return { before, after };
+}
+
+function renderSingle(args, before, after) {
+  if (args.json) {
+    const output = after
+      ? {
+          before: serializeAnalysis(args, before),
+          after: serializeAnalysis(args, after),
+        }
+      : serializeAnalysis(args, before);
+    return `${JSON.stringify(output, null, 2)}\n`;
+  }
+  return captureConsoleOutput(() => {
+    printAnalysisSummary(args, before);
+    if (after) {
+      console.log('');
+      console.log('--- After Withdraw ---');
+      printAnalysisSummary(args, after);
+    }
+  });
+}
+
+async function runSingleInvocation(args) {
+  const { before, after } = await executeSingle(args);
+  return renderSingle(args, before, after);
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.version) {
+    console.log('liquidity-depth 0.1.0');
+    return;
+  }
+  if (args.help || (!args.pool && !args.csv)) {
+    printHelp();
+    if (!args.pool && !args.csv) process.exitCode = 1;
+    return;
+  }
+
+  if (args.csv) {
+    await runBatch(args);
+    return;
+  }
+
+  const wantsTimeSeries =
+    args.timeStart != null ||
+    args.timeEnd != null ||
+    args.timeInterval != null ||
+    args.timeWindow != null ||
+    args.timeCount != null;
+  if (wantsTimeSeries) {
+    await runTimeSeries(args);
+    return;
+  }
+
+  try {
+    const output = await runSingleInvocation(args);
+    process.stdout.write(output);
+  } catch (e) {
+    if (
+      args.timestamp != null &&
+      args.rpc == null &&
+      String(e?.message || '').includes('--timestamp requires --rpc')
+    ) {
+      console.error('--timestamp requires --rpc (or RPC_URL env) to resolve block number');
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+
+function serializeAnalysis(args, analysis) {
+  const snap = analysis.snap;
+  const blockNumber =
+    snap.meta?.blockNumber ?? (analysis.blockNumber !== undefined ? analysis.blockNumber : undefined);
+  const timestamp =
+    snap.meta?.blockTimestamp ??
+    (analysis.timestampSec !== undefined ? analysis.timestampSec : undefined);
+  return {
+    pool: snap.meta.poolId,
+    tokens: {
+      token0: snap.meta.token0,
+      token1: snap.meta.token1,
+    },
+    ethPriceUSD: snap.meta.ethPriceUSD,
+    tick: snap.tick,
+    sqrtPriceX96: snap.sqrtPriceX96.toString(),
+    liquidity: snap.liquidity.toString(),
+    feePips: snap.feePips,
+    range: snap.meta.range,
+    percentBuckets: analysis.percentBuckets,
+    block: {
+      number: blockNumber != null ? String(blockNumber) : undefined,
+      timestamp: timestamp != null ? Number(timestamp) : undefined,
+      iso: formatTimestampUTC(timestamp),
+      input:
+        args.block ??
+        args.timestamp ??
+        (typeof analysis.blockTag === 'string' ? analysis.blockTag : undefined),
+    },
+    ...analysis.result,
+    priceImpacts: analysis.priceImpacts
+      ? {
+          usdSizes: analysis.usdSizes,
+          buyPct: analysis.priceImpacts.buyPct,
+          sellPct: analysis.priceImpacts.sellPct,
+        }
+      : undefined,
+    prices: {
+      token0: {
+        address: snap.meta.token0.id,
+        symbol: snap.meta.token0.symbol,
+        usd: analysis.token0USD,
+        source: analysis.priceSource0,
+      },
+      token1: {
+        address: snap.meta.token1.id,
+        symbol: snap.meta.token1.symbol,
+        usd: analysis.token1USD,
+        source: analysis.priceSource1,
+      },
+    },
+    buyCumToken1: analysis.result.buyCumToken1.map((value) => value.toString()),
+    sellCumToken0: analysis.result.sellCumToken0.map((value) => value.toString()),
+  };
+}
+
+function printAnalysisSummary(args, analysis) {
+  const snap = analysis.snap;
+  const result = analysis.result;
+  const fmtUSD = (value) =>
+    new Intl.NumberFormat('en-US', {
+      style: 'currency',
+      currency: 'USD',
+      maximumFractionDigits: 0,
+    }).format(value);
+
+  console.log(`Pool: ${args.pool.toLowerCase()}  [source: ${analysis.usedSource}]`);
+  const blockNumber =
+    snap.meta?.blockNumber ?? (analysis.blockNumber !== undefined ? analysis.blockNumber : undefined);
+  const timestamp =
+    snap.meta?.blockTimestamp ??
+    (analysis.timestampSec !== undefined ? analysis.timestampSec : undefined);
+  const blockInfoParts = [];
+  if (blockNumber != null) blockInfoParts.push(`#${String(blockNumber)}`);
+  const isoTimestamp = formatTimestampUTC(timestamp);
+  if (isoTimestamp) blockInfoParts.push(isoTimestamp);
+  if (blockNumber == null && typeof analysis.blockTag === 'string') {
+    blockInfoParts.push(analysis.blockTag);
+  }
+  if (blockInfoParts.length) console.log(`Block: ${blockInfoParts.join(' | ')}`);
+  console.log(
+    `Tokens: ${snap.meta.token0.symbol} (${snap.meta.token0.id}) / ${snap.meta.token1.symbol} (${snap.meta.token1.id})`
+  );
+  if (snap.meta?.ethPriceUSD) console.log(`ETH/USD: ${snap.meta.ethPriceUSD.toFixed(2)}`);
+  const feePct = snap.feePips / 10_000;
+  const feeBps = snap.feePips / 100;
+  console.log(`Tick: ${snap.tick}    Fee: ${feePct.toFixed(2)}% (${feeBps.toFixed(2)} bps)`);
+  if (analysis.token0USD || analysis.token1USD) {
+    const fmtPrice = (value) =>
+      value
+        ? `$${value.toLocaleString(undefined, { maximumFractionDigits: 6 })}`
+        : 'n/a';
+    console.log(
+      `Prices: ${snap.meta.token0.symbol} ${fmtPrice(analysis.token0USD)} (${analysis.priceSource0 || 'n/a'}), ${snap.meta.token1.symbol} ${fmtPrice(analysis.token1USD)} (${analysis.priceSource1 || 'n/a'})`
+    );
+  }
+  console.log(`Range: [${snap.meta.range.start}, ${snap.meta.range.end}] for ±${snap.meta.farPercent}%`);
+  console.log('');
+
+  const labels = analysis.percentBuckets.map((percent) => `${percent}%`);
+  console.log('Buy cumulative (token1 in → price up):');
+  labels.forEach((label, index) =>
+    console.log(`  +${label.padEnd(4)}: ${fmtUSD(result.buyCumUSD[index])}`)
+  );
+  console.log('Sell cumulative (token0 in → price down):');
+  labels.forEach((label, index) =>
+    console.log(`  -${label.padEnd(4)}: ${fmtUSD(result.sellCumUSD[index])}`)
+  );
+  console.log('');
+  console.log(`Headline Depth +2% : ${fmtUSD(result.depthPlus2USD)}`);
+  console.log(`Headline Depth -2% : ${fmtUSD(result.depthMinus2USD)}`);
+
+  if (!analysis.priceImpacts && analysis.usdSizes.length) {
+    console.log('');
+    console.log('Note: USD sizes provided but missing USD prices.');
+    console.log('      Pass --token0-usd and --token1-usd to enable price impact output.');
+  } else if (analysis.priceImpacts) {
+    console.log('');
+    console.log('Price impact by USD size:');
+    analysis.usdSizes.forEach((usd, index) => {
+      const buy = analysis.priceImpacts.buyPct[index];
+      const sell = analysis.priceImpacts.sellPct[index];
+      const fmtPct = (value) => `${value >= 0 ? '+' : ''}${value.toFixed(5)}%`;
+      console.log(`  $${usd.toLocaleString()}: buy ${fmtPct(buy)}   sell ${fmtPct(sell)}`);
+    });
+  }
+}
+
+main().catch((err) => {
+  console.error(err?.stack || err?.message || String(err));
+  process.exit(1);
+});