@steerprotocol/liquidity-meter 1.0.0

package/dist/cli/liquidity-depth.js

@@ -0,0 +1,1160 @@
+#!/usr/bin/env node
+// CLI for computing Uniswap v3 market depth bands with real data (TypeScript)
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile as _execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(_execFile);
+import { createMemoryClient, http } from 'tevm';
+import { getAddress, encodeFunctionData, parseEther, createPublicClient, http as viemHttp } from 'viem';
+import { sendTransaction as viemSendTransaction } from 'viem/actions';
+import * as tevmCommon from 'tevm/common';
+import * as viemChains from 'viem/chains';
+import { computeMarketDepthBands, computePriceImpactsBySizes } from '../core/depth.js';
+import { fetchPoolSnapshot as fetchFromSubgraph } from '../adapters/uniswapv3-subgraph.js';
+import { fetchPoolSnapshotViem } from '../adapters/onchain.js';
+import { fetchTokenUSDPrices } from '../prices.js';
+import { erc20Abi, steerVaultAbi, uniswapV3FactoryAbi } from '../wagmi/generated.js';
+const UNISWAP_V3_FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+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,
+    };
+    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|viem|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 === '--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 === '--throttle-ms')
+            args.throttleMs = Number(argv[++i]);
+        else if (a === '--retries')
+            args.retries = 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 && looksLikeAddress(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>] [--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)
+      --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)
+      --throttle-ms    N  Delay between CSV rows & retries (ms)
+      --retries        N  Retries per row on transient RPC errors (default: 0)
+      --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 throttle = async (ms) => {
+        if (!ms || ms <= 0)
+            return;
+        await new Promise((r) => setTimeout(r, ms));
+    };
+    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 = createMemoryClient({ fork: { transport: http(rpcUrl), blockTag: 'latest' }, loggingLevel: 'error' });
+        if (client.tevmReady)
+            await client.tevmReady();
+        try {
+            const pool = await client.readContract({ address: UNISWAP_V3_FACTORY, abi: uniswapV3FactoryAbi, functionName: 'getPool', args: [getAddress(t0), getAddress(t1), feeNum] });
+            if (pool && pool !== '0x0000000000000000000000000000000000000000')
+                return pool;
+        }
+        catch (_) {
+            // ignore
+        }
+        return undefined;
+    }
+    // base args to pass through from CLI
+    const base = [];
+    if (args.percent)
+        base.push('--percent', String(args.percent));
+    if (args.source)
+        base.push('--source', String(args.source));
+    if (args.rpc)
+        base.push('--rpc', String(args.rpc));
+    if (args.subgraph)
+        base.push('--subgraph', String(args.subgraph));
+    if (Number.isFinite(args.token0USD))
+        base.push('--token0-usd', String(args.token0USD));
+    if (Number.isFinite(args.token1USD))
+        base.push('--token1-usd', String(args.token1USD));
+    if (Number.isFinite(args.assumeStable))
+        base.push('--assume-stable', String(args.assumeStable));
+    if (args.usdSizes)
+        base.push('--usd-sizes', String(args.usdSizes));
+    if (args.prices)
+        base.push('--prices', String(args.prices));
+    if (args.reserveLimit)
+        base.push('--reserve-limit', String(args.reserveLimit));
+    if (args.json)
+        base.push('--json');
+    if (args.debug)
+        base.push('--debug');
+    if (args.owner)
+        base.push('--owner', String(args.owner));
+    if (Number.isFinite(args.withdrawPct))
+        base.push('--withdraw-pct', String(args.withdrawPct));
+    if (args.withdrawShares != null)
+        base.push('--withdraw-shares', String(args.withdrawShares));
+    const scriptPath = process.argv[1];
+    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 per = [...base];
+        const rpcs = pick(row, ['rpc', 'RPC', 'rpc_url', 'RPC_URL']);
+        if (rpcs)
+            per.push('--rpc', rpcs);
+        const source = pick(row, ['source', 'Source']);
+        if (source)
+            per.push('--source', source);
+        const percent = pick(row, ['percent', 'Percents', 'buckets']);
+        if (percent)
+            per.push('--percent', percent);
+        const token0USD = pick(row, ['token0_usd', 'token0-usd', 'token0USD']);
+        const token1USD = pick(row, ['token1_usd', 'token1-usd', 'token1USD']);
+        if (token0USD)
+            per.push('--token0-usd', String(token0USD));
+        if (token1USD)
+            per.push('--token1-usd', String(token1USD));
+        const usdSizes = pick(row, ['usd_sizes', 'usd-sizes', 'usdSizes']);
+        if (usdSizes)
+            per.push('--usd-sizes', usdSizes);
+        const assumeStable = pick(row, ['assume_stable', 'assume-stable', 'assumeStable']);
+        if (assumeStable != null)
+            per.push('--assume-stable', String(assumeStable));
+        const prices = pick(row, ['prices', 'Prices']);
+        if (prices)
+            per.push('--prices', String(prices));
+        const vault = pick(row, ['vault', 'Vault', 'vault_address', 'VaultAddress', 'vault address', 'strategy']);
+        if (vault)
+            per.push('--vault', vault);
+        const owner = pick(row, ['owner', 'Owner', 'owner_address', 'owner address', 'withdraw_owner', 'withdraw owner', 'account', 'user', 'recipient', 'to']);
+        if (owner)
+            per.push('--owner', owner);
+        const wpct = pick(row, ['withdraw_pct', 'withdraw-pct', 'withdraw percent', 'withdraw_percent', 'withdrawPercentage', 'withdrawPercent', 'pct_withdraw', 'percent_withdraw']);
+        if (wpct)
+            per.push('--withdraw-pct', String(wpct));
+        const wshares = pick(row, ['withdraw_shares', 'withdraw-shares', 'withdraw shares', 'withdrawShares', 'shares_to_withdraw', 'withdraw_share_amount']);
+        if (wshares)
+            per.push('--withdraw-shares', String(wshares));
+        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(' ')}`);
+        }
+        const poolStr = pool;
+        const argsArr = [scriptPath, '--pool', poolStr, ...per];
+        const maxRetries = Number.isFinite(args.retries) ? Math.max(0, Number(args.retries)) : 0;
+        let attempt = 0;
+        let done = false;
+        let lastErr = null;
+        while (!done && attempt <= maxRetries) {
+            try {
+                const { stdout, stderr } = await execFile(process.execPath, argsArr, { env: process.env, maxBuffer: 5 * 1024 * 1024 });
+                const baseName = `${poolStr.toLowerCase()}`;
+                const file = path.join(outdir, `${baseName}.${args.json ? 'json' : 'txt'}`);
+                const cleaned = cleanReportOutput(stdout);
+                await fs.writeFile(file, cleaned, 'utf8');
+                if (args.debug && stderr)
+                    process.stderr.write(stderr);
+                console.log(`Wrote: ${file}`);
+                done = true;
+            }
+            catch (err) {
+                lastErr = err;
+                const errText = String(err?.stderr || err?.stdout || err?.message || err || '');
+                const isTransient = /jsonrpc|Unknown error in jsonrpc request|proof window|ETIMEOUT|ECONNRESET|429|rate limit/i.test(errText);
+                const willRetry = attempt < maxRetries && isTransient;
+                if (args.debug)
+                    console.error(`[batch] row ${idx + 1} attempt ${attempt + 1}/${maxRetries + 1} ${willRetry ? 'retrying' : 'failed'}: ${errText.split('\n')[0]}`);
+                if (!willRetry)
+                    break;
+                const backoff = (args.throttleMs ?? 0) + Math.min(2000, 250 * (attempt + 1));
+                await throttle(backoff);
+                attempt += 1;
+            }
+        }
+        if (!done) {
+            const errMsg = String(lastErr?.stderr || lastErr?.stdout || lastErr?.message || lastErr || '');
+            const errFile = path.join(outdir, `error-${poolStr.toLowerCase()}.txt`);
+            await fs.writeFile(errFile, errMsg, 'utf8');
+            console.error(`Failed row ${idx + 1} (${poolStr}): ${lastErr?.message || lastErr}`);
+            console.error(`  -> see ${errFile}`);
+        }
+        // throttle between rows to respect provider limits
+        await throttle(args.throttleMs);
+    }
+}
+// Strip noisy logs (e.g., TEVM warnings) from report files while preserving CLI output
+function cleanReportOutput(s) {
+    try {
+        const lines = String(s || '').split(/\r?\n/);
+        const out = [];
+        for (const line of lines) {
+            if (!line) {
+                out.push(line);
+                continue;
+            }
+            // Filter known noisy patterns
+            if (line.includes('"name":"@tevm/'))
+                continue; // TEVM structured logs
+            if (/\bEIP-7702\b/i.test(line))
+                continue; // EIP-7702 warning block
+            if (/^\s*\{\s*chainId\s*:/i.test(line))
+                continue; // stray chainId object
+            if (/^\s*0x[0-9a-fA-F]+\s*$/.test(line))
+                continue; // bare hex line
+            out.push(line);
+        }
+        // Trim leading empty lines left by filtering
+        while (out.length && out[0].trim() === '')
+            out.shift();
+        return out.join('\n');
+    }
+    catch (_) {
+        return s;
+    }
+}
+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 percentBuckets = args.percent
+        .split(',')
+        .map((x) => Number(x.trim()))
+        .filter((x) => Number.isFinite(x) && x > 0)
+        .sort((a, b) => a - b);
+    if (!percentBuckets.length) {
+        console.error('No valid percent buckets parsed.');
+        process.exit(1);
+    }
+    // Choose data source and initialize clients as needed (match original JS behavior)
+    let client = null;
+    let usedSource = args.source;
+    if (args.source === 'viem' || args.source === 'tevm' || (args.source === 'auto' && args.rpc)) {
+        if (!args.rpc) {
+            console.error('Missing --rpc (or RPC_URL env) for tevm source.');
+            process.exit(1);
+        }
+        const common = await resolveTevmCommon(args.rpc);
+        client = createMemoryClient({ fork: { transport: http(args.rpc), blockTag: 'latest' }, loggingLevel: 'error', ...(common ? { common } : {}) });
+        if (client.tevmReady)
+            await client.tevmReady();
+        usedSource = 'tevm';
+    }
+    else if (args.source === 'subgraph' || args.source === 'auto') {
+        usedSource = 'subgraph';
+    }
+    else {
+        console.error(`Unknown --source: ${args.source}`);
+        process.exit(1);
+    }
+    // Fetch pool snapshot + ticks in range (via selected source)
+    let snap;
+    if (usedSource === 'tevm') {
+        snap = await fetchPoolSnapshotViem({ poolAddress: args.pool, rpcUrl: args.rpc, percentBuckets, client: client || undefined });
+    }
+    else {
+        snap = await fetchFromSubgraph({ poolAddress: args.pool, percentBuckets, subgraphUrl: args.subgraph });
+    }
+    // Fill USD prices if provided or can infer from stable coin
+    const usd0 = Number.isFinite(args.token0USD) ? args.token0USD : snap.token0.usdPrice;
+    const usd1 = Number.isFinite(args.token1USD) ? args.token1USD : snap.token1.usdPrice;
+    // Infer/fetch missing USD using pool price, price APIs, or stable-coin hint
+    let token0USD = usd0;
+    let token1USD = usd1;
+    const dec0 = snap.token0.decimals;
+    const dec1 = snap.token1.decimals;
+    const price1Per0 = Math.pow(1.0001, snap.tick) * Math.pow(10, dec0 - dec1); // token1 tokens per 1 token0
+    if (!usd0 && usd1)
+        token0USD = usd1 * price1Per0;
+    if (usd0 && !usd1)
+        token1USD = usd0 / price1Per0;
+    let priceSource0 = usd0 ? 'override' : undefined;
+    let priceSource1 = usd1 ? 'override' : undefined;
+    if ((!token0USD || !token1USD)) {
+        // Try external price APIs if addresses present
+        try {
+            const addrs = [(snap.meta?.token0?.id || snap.token0.id), (snap.meta?.token1?.id || snap.token1.id)].map((x) => x.toLowerCase());
+            let chainIdForPrices;
+            try {
+                if (args.rpc) {
+                    const clientCID = createMemoryClient({ fork: { transport: http(args.rpc), blockTag: 'latest' }, loggingLevel: 'error' });
+                    if (clientCID.tevmReady)
+                        await clientCID.tevmReady();
+                    chainIdForPrices = await clientCID.getChainId();
+                }
+            }
+            catch (_) { }
+            if (args.debug) {
+                console.error(`[cli] price fetch: addrs=${addrs.join(',')} source=${args.prices} rpc=${args.rpc ? 'yes' : 'no'} chainId=${chainIdForPrices ?? 'n/a'}`);
+            }
+            const { byAddress } = await fetchTokenUSDPrices({ addresses: addrs, source: args.prices, chainId: chainIdForPrices, rpcUrl: args.rpc, debug: !!args.debug, reserveLimit: args.reserveLimit });
+            const p0 = byAddress[addrs[0]];
+            const p1 = byAddress[addrs[1]];
+            if (!token0USD && p0) {
+                token0USD = p0.price;
+                priceSource0 = p0.source;
+            }
+            if (!token1USD && p1) {
+                token1USD = p1.price;
+                priceSource1 = p1.source;
+            }
+            // Cross-derive the missing side using pool price if only one side priced
+            if (token0USD && !token1USD) {
+                token1USD = token0USD / price1Per0;
+                if (!priceSource1)
+                    priceSource1 = 'derived';
+            }
+            if (!token0USD && token1USD) {
+                token0USD = token1USD * price1Per0;
+                if (!priceSource0)
+                    priceSource0 = 'derived';
+            }
+        }
+        catch (_) {
+            // ignore, fall back to heuristics below
+        }
+    }
+    // If subgraph already provided USD
+    if (!priceSource0 && usd0)
+        priceSource0 = 'subgraph';
+    if (!priceSource1 && usd1)
+        priceSource1 = 'subgraph';
+    if ((!token0USD || !token1USD)) {
+        if (args.assumeStable === 0 || /USD|USDC|USDT|DAI/i.test((snap.meta?.token0?.symbol || ''))) {
+            if (!token0USD) {
+                token0USD = 1;
+                priceSource0 = 'inferred';
+            }
+            if (!token1USD) {
+                token1USD = 1 / price1Per0;
+                priceSource1 = 'inferred';
+            }
+        }
+        else if (args.assumeStable === 1 || /USD|USDC|USDT|DAI/i.test((snap.meta?.token1?.symbol || ''))) {
+            if (!token1USD) {
+                token1USD = 1;
+                priceSource1 = 'inferred';
+            }
+            if (!token0USD) {
+                token0USD = price1Per0;
+                priceSource0 = 'inferred';
+            }
+        }
+    }
+    if (args.debug) {
+        console.error(`[cli] usd results: token0=${token0USD ?? 'n/a'} src0=${priceSource0 ?? 'n/a'} token1=${token1USD ?? 'n/a'} src1=${priceSource1 ?? 'n/a'}`);
+    }
+    // If still missing, mark source explicitly
+    if (!priceSource0 && token0USD)
+        priceSource0 = 'inferred';
+    if (!priceSource1 && token1USD)
+        priceSource1 = 'inferred';
+    const result = computeMarketDepthBands({
+        sqrtPriceX96: snap.sqrtPriceX96,
+        tick: snap.tick,
+        liquidity: snap.liquidity,
+        feePips: snap.feePips,
+        ticks: snap.ticks,
+        token0: { decimals: snap.token0.decimals, usdPrice: token0USD || 0 },
+        token1: { decimals: snap.token1.decimals, usdPrice: token1USD || 0 },
+        percentBuckets,
+    });
+    // Parse USD sizes for price impact
+    const usdSizes = args.usdSizes
+        .split(',')
+        .map((x) => Number(x.trim()))
+        .filter((x) => Number.isFinite(x) && x > 0)
+        .sort((a, b) => a - b);
+    // Convert USD -> raw token amounts (BigInt) with micro-dollar precision to avoid FP drift
+    function usdToRaw(usd, usdPrice, decimals) {
+        if (!usdPrice || usdPrice <= 0)
+            return 0n;
+        const micros = Math.round(usd * 1e6);
+        const usdMicrosPrice = Math.round(usdPrice * 1e6);
+        if (usdMicrosPrice <= 0)
+            return 0n;
+        const scale = 10n ** BigInt(decimals);
+        return (BigInt(micros) * scale) / BigInt(usdMicrosPrice);
+    }
+    let priceImpacts = null;
+    if (usdSizes.length && token0USD && token1USD) {
+        const buySizesToken1 = usdSizes.map((u) => usdToRaw(u, token1USD, snap.token1.decimals));
+        const sellSizesToken0 = usdSizes.map((u) => usdToRaw(u, token0USD, snap.token0.decimals));
+        priceImpacts = computePriceImpactsBySizes({
+            sqrtPriceX96: snap.sqrtPriceX96,
+            tick: snap.tick,
+            liquidity: snap.liquidity,
+            feePips: snap.feePips,
+            ticks: snap.ticks,
+            buySizesToken1,
+            sellSizesToken0,
+        });
+    }
+    // Helper to compute prices + metrics for a given snapshot (used for after-withdraw)
+    async function computeMetrics({ args, snap, usedSource, percentBuckets }) {
+        // Fill USD prices if provided or can infer from stable coin
+        const usd0 = Number.isFinite(args.token0USD) ? args.token0USD : snap.token0.usdPrice;
+        const usd1 = Number.isFinite(args.token1USD) ? args.token1USD : snap.token1.usdPrice;
+        let token0USD = usd0;
+        let token1USD = usd1;
+        const dec0 = snap.token0.decimals;
+        const dec1 = snap.token1.decimals;
+        const price1Per0 = Math.pow(1.0001, snap.tick) * Math.pow(10, dec0 - dec1);
+        if (!usd0 && usd1)
+            token0USD = usd1 * price1Per0;
+        if (usd0 && !usd1)
+            token1USD = usd0 / price1Per0;
+        let priceSource0 = usd0 ? 'override' : undefined;
+        let priceSource1 = usd1 ? 'override' : undefined;
+        if ((!token0USD || !token1USD)) {
+            try {
+                const addrs = [snap.meta?.token0?.id || snap.token0.id, snap.meta?.token1?.id || snap.token1.id].map((x) => x.toLowerCase());
+                let chainIdForPrices;
+                try {
+                    if (args.rpc) {
+                        const clientCID = createMemoryClient({ fork: { transport: http(args.rpc), blockTag: 'latest' }, loggingLevel: 'error' });
+                        if (clientCID.tevmReady)
+                            await clientCID.tevmReady();
+                        chainIdForPrices = await clientCID.getChainId();
+                    }
+                }
+                catch (_) { }
+                if (args.debug) {
+                    console.error(`[cli] price fetch: addrs=${addrs.join(',')} source=${args.prices} rpc=${args.rpc ? 'yes' : 'no'} chainId=${chainIdForPrices ?? 'n/a'}`);
+                }
+                const { byAddress } = await fetchTokenUSDPrices({ addresses: addrs, source: args.prices, chainId: chainIdForPrices, rpcUrl: args.rpc, debug: !!args.debug, reserveLimit: args.reserveLimit });
+                const p0 = byAddress[addrs[0]];
+                const p1 = byAddress[addrs[1]];
+                if (!token0USD && p0) {
+                    token0USD = p0.price;
+                    priceSource0 = p0.source;
+                }
+                if (!token1USD && p1) {
+                    token1USD = p1.price;
+                    priceSource1 = p1.source;
+                }
+                if (token0USD && !token1USD) {
+                    token1USD = token0USD / price1Per0;
+                    if (!priceSource1)
+                        priceSource1 = 'derived';
+                }
+                if (!token0USD && token1USD) {
+                    token0USD = token1USD * price1Per0;
+                    if (!priceSource0)
+                        priceSource0 = 'derived';
+                }
+            }
+            catch (_) { }
+        }
+        if (!priceSource0 && usd0)
+            priceSource0 = 'subgraph';
+        if (!priceSource1 && usd1)
+            priceSource1 = 'subgraph';
+        if ((!token0USD || !token1USD)) {
+            if (args.assumeStable === 0 || /USD|USDC|USDT|DAI/i.test(snap.meta?.token0?.symbol || '')) {
+                if (!token0USD) {
+                    token0USD = 1;
+                    priceSource0 = 'inferred';
+                }
+                if (!token1USD) {
+                    token1USD = 1 / price1Per0;
+                    priceSource1 = 'inferred';
+                }
+            }
+            else if (args.assumeStable === 1 || /USD|USDC|USDT|DAI/i.test(snap.meta?.token1?.symbol || '')) {
+                if (!token1USD) {
+                    token1USD = 1;
+                    priceSource1 = 'inferred';
+                }
+                if (!token0USD) {
+                    token0USD = price1Per0;
+                    priceSource0 = 'inferred';
+                }
+            }
+        }
+        if (!priceSource0 && token0USD)
+            priceSource0 = 'inferred';
+        if (!priceSource1 && token1USD)
+            priceSource1 = 'inferred';
+        const result = computeMarketDepthBands({
+            sqrtPriceX96: snap.sqrtPriceX96,
+            tick: snap.tick,
+            liquidity: snap.liquidity,
+            feePips: snap.feePips,
+            ticks: snap.ticks,
+            token0: { decimals: snap.token0.decimals, usdPrice: token0USD || 0 },
+            token1: { decimals: snap.token1.decimals, usdPrice: token1USD || 0 },
+            percentBuckets,
+        });
+        const usdSizes = (args.usdSizes || '')
+            .split(',')
+            .map((x) => Number(x.trim()))
+            .filter((x) => Number.isFinite(x) && x > 0)
+            .sort((a, b) => a - b);
+        function usdToRaw(usd, usdPrice, decimals) {
+            if (!usdPrice || usdPrice <= 0)
+                return 0n;
+            const micros = Math.round(usd * 1e6);
+            const usdMicrosPrice = Math.round(usdPrice * 1e6);
+            if (usdMicrosPrice <= 0)
+                return 0n;
+            const scale = 10n ** BigInt(decimals);
+            return (BigInt(micros) * scale) / BigInt(usdMicrosPrice);
+        }
+        let priceImpacts = null;
+        if (usdSizes.length && token0USD && token1USD) {
+            const buySizesToken1 = usdSizes.map((u) => usdToRaw(u, token1USD, snap.token1.decimals));
+            const sellSizesToken0 = usdSizes.map((u) => usdToRaw(u, token0USD, snap.token0.decimals));
+            priceImpacts = computePriceImpactsBySizes({
+                sqrtPriceX96: snap.sqrtPriceX96,
+                tick: snap.tick,
+                liquidity: snap.liquidity,
+                feePips: snap.feePips,
+                ticks: snap.ticks,
+                buySizesToken1,
+                sellSizesToken0,
+            });
+        }
+        return { token0USD, token1USD, priceSource0, priceSource1, priceImpacts, usdSizes, result, percentBuckets };
+    }
+    // If a vault withdrawal simulation is requested, perform it and compute the post-withdraw metrics using the same client/fork.
+    let after = null;
+    if (usedSource === 'tevm' && args.vault && (Number.isFinite(args.withdrawPct) || args.withdrawShares != null)) {
+        const viemChain = await resolveViemChain(args.rpc);
+        await simulateVaultWithdraw({ client: client, vault: args.vault, owner: args.owner, withdrawPct: args.withdrawPct, withdrawShares: args.withdrawShares, debug: !!args.debug, cliPool: args.pool, viemChain });
+        const snap2 = await fetchPoolSnapshotViem({ poolAddress: args.pool, client: client || undefined, percentBuckets });
+        if (args.debug) {
+            console.error(`[after] tick: ${snap.tick} -> ${snap2.tick}`);
+            console.error(`[after] liquidity: ${snap.liquidity.toString()} -> ${snap2.liquidity.toString()}`);
+        }
+        // Recompute prices and metrics for the post-withdraw state
+        const { token0USD: token0USD2, token1USD: token1USD2, priceSource0: priceSource0b, priceSource1: priceSource1b, priceImpacts: priceImpacts2, usdSizes: usdSizes2, result: result2, percentBuckets: percentBuckets2 } = await computeMetrics({ args, snap: snap2, usedSource, percentBuckets });
+        after = { snap: snap2, token0USD: token0USD2, token1USD: token1USD2, priceSource0: priceSource0b, priceSource1: priceSource1b, priceImpacts: priceImpacts2, usdSizes: usdSizes2, result: result2, percentBuckets: percentBuckets2 };
+    }
+    if (args.json && !after) {
+        console.log(JSON.stringify({
+            pool: snap.meta.poolId,
+            tokens: {
+                token0: snap.meta.token0,
+                token1: snap.meta.token1,
+            },
+            ethPriceUSD: snap.meta.ethPriceUSD,
+            tick: snap.tick,
+            sqrtPriceX96: String(snap.sqrtPriceX96),
+            liquidity: String(snap.liquidity),
+            feePips: snap.feePips,
+            range: snap.meta.range,
+            percentBuckets,
+            ...result,
+            priceImpacts: priceImpacts
+                ? { usdSizes, buyPct: priceImpacts.buyPct, sellPct: priceImpacts.sellPct }
+                : undefined,
+            prices: {
+                token0: { address: snap.meta.token0.id, symbol: snap.meta.token0.symbol, usd: token0USD, source: priceSource0 },
+                token1: { address: snap.meta.token1.id, symbol: snap.meta.token1.symbol, usd: token1USD, source: priceSource1 },
+            },
+            // convert BigInt arrays to string for JSON safety
+            buyCumToken1: result.buyCumToken1.map((x) => String(x)),
+            sellCumToken0: result.sellCumToken0.map((x) => String(x)),
+        }, null, 2));
+        return;
+    }
+    if (args.json && after) {
+        const out = {
+            before: {
+                pool: snap.meta.poolId,
+                tokens: { token0: snap.meta.token0, token1: snap.meta.token1 },
+                ethPriceUSD: snap.meta.ethPriceUSD,
+                tick: snap.tick,
+                sqrtPriceX96: String(snap.sqrtPriceX96),
+                liquidity: String(snap.liquidity),
+                feePips: snap.feePips,
+                range: snap.meta.range,
+                percentBuckets,
+                ...result,
+                priceImpacts: priceImpacts ? { usdSizes, buyPct: priceImpacts.buyPct, sellPct: priceImpacts.sellPct } : undefined,
+                prices: {
+                    token0: { address: snap.meta.token0.id, symbol: snap.meta.token0.symbol, usd: token0USD, source: priceSource0 },
+                    token1: { address: snap.meta.token1.id, symbol: snap.meta.token1.symbol, usd: token1USD, source: priceSource1 },
+                },
+                buyCumToken1: result.buyCumToken1.map((x) => String(x)),
+                sellCumToken0: result.sellCumToken0.map((x) => String(x)),
+            },
+            after: {
+                pool: after.snap.meta.poolId,
+                tokens: { token0: after.snap.meta.token0, token1: after.snap.meta.token1 },
+                ethPriceUSD: after.snap.meta.ethPriceUSD,
+                tick: after.snap.tick,
+                sqrtPriceX96: String(after.snap.sqrtPriceX96),
+                liquidity: String(after.snap.liquidity),
+                feePips: after.snap.feePips,
+                range: after.snap.meta.range,
+                percentBuckets: after.percentBuckets,
+                ...after.result,
+                priceImpacts: after.priceImpacts ? { usdSizes: after.usdSizes, buyPct: after.priceImpacts.buyPct, sellPct: after.priceImpacts.sellPct } : undefined,
+                prices: {
+                    token0: { address: after.snap.meta.token0.id, symbol: after.snap.meta.token0.symbol, usd: after.token0USD, source: after.priceSource0 },
+                    token1: { address: after.snap.meta.token1.id, symbol: after.snap.meta.token1.symbol, usd: after.token1USD, source: after.priceSource1 },
+                },
+                buyCumToken1: after.result.buyCumToken1.map((x) => String(x)),
+                sellCumToken0: after.result.sellCumToken0.map((x) => String(x)),
+            },
+        };
+        console.log(JSON.stringify(out, null, 2));
+        return;
+    }
+    // Pretty print summary
+    const fmtUSD = (n) => new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 0 }).format(n);
+    console.log(`Pool: ${args.pool.toLowerCase()}  [source: ${usedSource}]`);
+    console.log(`Tokens: ${snap.meta.token0.symbol} ${snap.meta.token0.id ? `(${snap.meta.token0.id})` : ''} / ${snap.meta.token1.symbol} ${snap.meta.token1.id ? `(${snap.meta.token1.id})` : ''}`);
+    if (snap.meta?.ethPriceUSD)
+        console.log(`ETH/USD: ${Number(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 (token0USD || token1USD) {
+        const fmt = (v) => (v ? `$${v.toLocaleString(undefined, { maximumFractionDigits: 6 })}` : 'n/a');
+        const src0 = priceSource0 || 'n/a';
+        const src1 = priceSource1 || 'n/a';
+        console.log(`Prices: ${snap.meta.token0.symbol} ${fmt(token0USD)} (${src0}), ${snap.meta.token1.symbol} ${fmt(token1USD)} (${src1})`);
+    }
+    console.log(`Range: [${snap.meta.range.start}, ${snap.meta.range.end}] for ±${snap.meta.farPercent}%`);
+    console.log('');
+    const labels = percentBuckets.map((p) => `${p}%`);
+    console.log(`Buy cumulative (token1 in → price up):`);
+    labels.forEach((lab, i) => console.log(`  +${lab.padEnd(4)}: ${fmtUSD(result.buyCumUSD[i])}`));
+    console.log(`Sell cumulative (token0 in → price down):`);
+    labels.forEach((lab, i) => console.log(`  -${lab.padEnd(4)}: ${fmtUSD(result.sellCumUSD[i])}`));
+    console.log('');
+    console.log(`Headline Depth +2% : ${fmtUSD(result.depthPlus2USD)}`);
+    console.log(`Headline Depth -2% : ${fmtUSD(result.depthMinus2USD)}`);
+    if (!priceImpacts && 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 (priceImpacts) {
+        console.log('');
+        console.log('Price impact by USD size:');
+        usdSizes.forEach((u, i) => {
+            const buy = priceImpacts.buyPct[i];
+            const sell = priceImpacts.sellPct[i];
+            const fmt = (x) => `${x >= 0 ? '+' : ''}${x.toFixed(5)}%`;
+            console.log(`  $${u.toLocaleString()}: buy ${fmt(buy)}   sell ${fmt(sell)}`);
+        });
+    }
+    // If we computed an 'after' snapshot, append a second pretty-printed section.
+    if (after) {
+        const snapA = after.snap;
+        const resultA = after.result;
+        const token0USDA = after.token0USD;
+        const token1USDA = after.token1USD;
+        const priceImpactsA = after.priceImpacts;
+        const usdSizesA = after.usdSizes;
+        console.log('');
+        console.log('--- After Withdraw ---');
+        console.log(`Tokens: ${snapA.meta.token0.symbol} (${snapA.meta.token0.id}) / ${snapA.meta.token1.symbol} (${snapA.meta.token1.id})`);
+        if (snapA.meta?.ethPriceUSD)
+            console.log(`ETH/USD: ${Number(snapA.meta.ethPriceUSD).toFixed(2)}`);
+        const feePctA = snapA.feePips / 10_000;
+        const feeBpsA = snapA.feePips / 100;
+        console.log(`Tick: ${snapA.tick}    Fee: ${feePctA.toFixed(2)}% (${feeBpsA.toFixed(2)} bps)`);
+        if (token0USDA || token1USDA) {
+            const fmt = (v) => (v ? `$${v.toLocaleString(undefined, { maximumFractionDigits: 6 })}` : 'n/a');
+            const src0 = after.priceSource0 || 'n/a';
+            const src1 = after.priceSource1 || 'n/a';
+            console.log(`Prices: ${snapA.meta.token0.symbol} ${fmt(token0USDA)} (${src0}), ${snapA.meta.token1.symbol} ${fmt(token1USDA)} (${src1})`);
+        }
+        console.log(`Range: [${snapA.meta.range.start}, ${snapA.meta.range.end}] for ±${snapA.meta.farPercent}%`);
+        console.log('');
+        const labelsA = percentBuckets.map((p) => `${p}%`);
+        console.log(`Buy cumulative (token1 in → price up):`);
+        labelsA.forEach((lab, i) => console.log(`  +${lab.padEnd(4)}: ${fmtUSD(resultA.buyCumUSD[i])}`));
+        console.log(`Sell cumulative (token0 in → price down):`);
+        labelsA.forEach((lab, i) => console.log(`  -${lab.padEnd(4)}: ${fmtUSD(resultA.sellCumUSD[i])}`));
+        console.log('');
+        console.log(`Headline Depth +2% : ${fmtUSD(resultA.depthPlus2USD)}`);
+        console.log(`Headline Depth -2% : ${fmtUSD(resultA.depthMinus2USD)}`);
+        if (!priceImpactsA && usdSizesA.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 (priceImpactsA) {
+            console.log('');
+            console.log('Price impact by USD size:');
+            usdSizesA.forEach((u, i) => {
+                const buy = priceImpactsA.buyPct[i];
+                const sell = priceImpactsA.sellPct[i];
+                const fmt = (x) => `${x >= 0 ? '+' : ''}${x.toFixed(5)}%`;
+                console.log(`  $${u.toLocaleString()}: buy ${fmt(buy)}   sell ${fmt(sell)}`);
+            });
+        }
+    }
+}
+main().catch((err) => {
+    console.error(err?.stack || err?.message || String(err));
+    process.exit(1);
+});
+// --- Helpers for Tevm simulation ---
+// ABIs come from wagmi CLI generated types
+async function simulateVaultWithdraw({ client, vault, owner, withdrawPct, withdrawShares, debug = false, cliPool, viemChain }) {
+    if (!client)
+        throw new Error('simulateVaultWithdraw requires tevm client');
+    if (!vault)
+        throw new Error('Missing --vault');
+    if (!owner)
+        throw new Error('Missing --owner for withdraw simulation');
+    const vaultAddr = getAddress(vault);
+    const ownerAddr = getAddress(owner);
+    // Resolve vault + token details
+    let poolAddr;
+    try {
+        poolAddr = await client.readContract({ address: vaultAddr, abi: steerVaultAbi, functionName: 'pool' });
+    }
+    catch (e) {
+        throw new Error(`Failed to read vault.pool(): ${e?.message || e}`);
+    }
+    let vDec = 18;
+    try {
+        vDec = Number(await client.readContract({ address: vaultAddr, abi: steerVaultAbi, functionName: 'decimals' }));
+    }
+    catch (_) { }
+    const t0Addr = await client.readContract({ address: vaultAddr, abi: steerVaultAbi, functionName: 'token0' });
+    const t1Addr = await client.readContract({ address: vaultAddr, abi: steerVaultAbi, functionName: 'token1' });
+    const [t0Dec, t1Dec] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'decimals' }),
+        client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'decimals' }),
+    ]);
+    let [t0Sym, t1Sym] = ['T0', 'T1'];
+    try {
+        t0Sym = await client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'symbol' });
+    }
+    catch (_) { }
+    try {
+        t1Sym = await client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'symbol' });
+    }
+    catch (_) { }
+    const fmtUnits = (bn, dec) => {
+        try {
+            let v = BigInt(bn);
+            const neg = v < 0n;
+            if (neg)
+                v = -v;
+            const s = v.toString().padStart(Number(dec) + 1, '0');
+            const i = s.slice(0, s.length - Number(dec));
+            const f = s.slice(s.length - Number(dec)).replace(/0+$/, '').slice(0, 8);
+            return (neg ? '-' : '') + i + (f ? '.' + f : '');
+        }
+        catch (_) {
+            return String(bn);
+        }
+    };
+    const fmt = (bn, dec, sym) => `${fmtUnits(bn, dec)} ${sym || ''}`.trim();
+    // Determine shares to withdraw
+    let shares = null;
+    if (withdrawShares != null) {
+        try {
+            shares = BigInt(String(withdrawShares));
+        }
+        catch (_) {
+            throw new Error('--withdraw-shares must be a BigInt-compatible value');
+        }
+    }
+    else if (Number.isFinite(withdrawPct)) {
+        const bal = await client.readContract({ address: vaultAddr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] });
+        const pct = BigInt(Math.max(0, Math.min(100, Math.floor(Number(withdrawPct)))));
+        shares = (BigInt(bal) * pct) / 100n;
+    }
+    const ownerShares = await client.readContract({ address: vaultAddr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] });
+    const totalShares = await client.readContract({ address: vaultAddr, abi: erc20Abi, functionName: 'totalSupply' });
+    if (debug) {
+        const poolWarn = cliPool && cliPool.toLowerCase() !== poolAddr.toLowerCase() ? ` (CLI pool=${cliPool})` : '';
+        console.error(`[withdraw] vault=${vaultAddr} pool=${poolAddr}${poolWarn}`);
+        console.error(`[withdraw] owner=${ownerAddr} ownerShares=${fmt(ownerShares, vDec, 'shares')} totalSupply=${fmt(totalShares, vDec, 'shares')}`);
+        console.error(`[withdraw] planned shares=${fmt(shares ?? 0n, vDec, 'shares')} (${Number(withdrawPct ?? 0)}%)`);
+    }
+    if (!shares || shares <= 0n) {
+        if (debug)
+            console.error('[withdraw] no shares to withdraw; skipping');
+        return false;
+    }
+    // Fund owner for gas and impersonate
+    try {
+        await client.setBalance?.({ address: ownerAddr, value: parseEther('0.05') });
+    }
+    catch (_) { }
+    try {
+        await client.impersonateAccount?.({ address: ownerAddr });
+    }
+    catch (_) { }
+    // Balances before
+    const [o0b, o1b, v0b, v1b] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'balanceOf', args: [vaultAddr] }),
+        client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'balanceOf', args: [vaultAddr] }),
+    ]);
+    if (debug) {
+        console.error(`[withdraw] owner balances before: ${fmt(o0b, t0Dec, t0Sym)}, ${fmt(o1b, t1Dec, t1Sym)}`);
+        console.error(`[withdraw] vault  balances before: ${fmt(v0b, t0Dec, t0Sym)}, ${fmt(v1b, t1Dec, t1Sym)}`);
+    }
+    // Build and send withdraw tx
+    const data = encodeFunctionData({ abi: steerVaultAbi, functionName: 'withdraw', args: [shares, 0n, 0n, ownerAddr] });
+    try {
+        // Provide chain (common) to satisfy viem wallet action requirements
+        const chain = viemChain || await resolveViemChainFromClient(client);
+        const hash = await viemSendTransaction(client, { account: ownerAddr, to: vaultAddr, data, chain });
+        if (debug)
+            console.error(`[withdraw] tx sent: ${hash}`);
+    }
+    catch (e) {
+        if (debug)
+            console.error(`[withdraw] sendTransaction error: ${e?.message || e}`);
+        throw e;
+    }
+    await client.mine?.({ blocks: 1 });
+    // Balances after
+    const [o0a, o1a, v0a, v1a] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t0Addr, abi: erc20Abi, functionName: 'balanceOf', args: [vaultAddr] }),
+        client.readContract({ address: t1Addr, abi: erc20Abi, functionName: 'balanceOf', args: [vaultAddr] }),
+    ]);
+    const d0 = BigInt(o0a) - BigInt(o0b);
+    const d1 = BigInt(o1a) - BigInt(o1b);
+    if (debug) {
+        console.error(`[withdraw] owner balances after : ${fmt(o0a, t0Dec, t0Sym)}, ${fmt(o1a, t1Dec, t1Sym)}`);
+        console.error(`[withdraw] vault  balances after : ${fmt(v0a, t0Dec, t0Sym)}, ${fmt(v1a, t1Dec, t1Sym)}`);
+        console.error(`[withdraw] owner deltas: ${fmt(d0, t0Dec, t0Sym)}, ${fmt(d1, t1Dec, t1Sym)}`);
+    }
+    return true;
+}
+// Resolve a tevm/common chain object for a given RPC (by chainId)
+async function resolveTevmCommon(rpcUrl) {
+    try {
+        if (!rpcUrl)
+            return undefined;
+        const pc = createPublicClient({ transport: viemHttp(rpcUrl) });
+        const id = await pc.getChainId();
+        for (const v of Object.values(tevmCommon)) {
+            if (v && typeof v === 'object' && 'id' in v && v.id === id)
+                return v;
+        }
+    }
+    catch (_) { }
+    return undefined;
+}
+// Resolve tevm/common by introspecting an existing client
+async function resolveTevmCommonFromClient(client) {
+    try {
+        const id = await client.getChainId();
+        for (const v of Object.values(tevmCommon)) {
+            if (v && typeof v === 'object' && 'id' in v && v.id === id)
+                return v;
+        }
+    }
+    catch (_) { }
+    return undefined;
+}
+// Resolve a viem Chain object for a given RPC (by chainId)
+async function resolveViemChain(rpcUrl) {
+    try {
+        if (!rpcUrl)
+            return undefined;
+        const pc = createPublicClient({ transport: viemHttp(rpcUrl) });
+        const id = await pc.getChainId();
+        for (const v of Object.values(viemChains)) {
+            if (v && typeof v === 'object' && 'id' in v && v.id === id)
+                return v;
+        }
+    }
+    catch (_) { }
+    return undefined;
+}
+// Resolve viem Chain by introspecting an existing client
+async function resolveViemChainFromClient(client) {
+    try {
+        const id = await client.getChainId();
+        for (const v of Object.values(viemChains)) {
+            if (v && typeof v === 'object' && 'id' in v && v.id === id)
+                return v;
+        }
+    }
+    catch (_) { }
+    return undefined;
+}