@steerprotocol/liquidity-meter 1.0.0

package/README.md

@@ -0,0 +1,207 @@
+Liquidity Depth CLI
+
+- Compute Uniswap v3 market depth bands (±1/2/5/10% by default) using live on-chain state or subgraph.
+- Estimate price impact for given USD trade sizes.
+- Batch over many pools from CSV.
+- Simulate Steer vault withdrawals on a fork and re-run the analysis “after” to see slippage effects.
+
+Requirements
+
+- Node.js 18+ (uses global fetch and BigInt)
+- For on-chain mode: an Ethereum RPC URL in `--rpc` (or env `RPC_URL`) capable of eth_getProof. For Base, prefer `https://developer-access-mainnet.base.org`.
+
+Install
+
+- Node module consumers (after publish):
+  - `npm install liquidity-meter`
+  - ESM-only: import from `liquidity-meter` in Node 18+
+- Local (from this repo):
+  - `npm install`
+  - `npm run generate && npm run build`
+  - `npm link` (optional; installs `liquidity-depth` in your PATH)
+
+ESM Only
+
+- This package ships ESM only. Use Node 18+ and `import` syntax.
+- Exports:
+  - `import { analyzePool, fetchPoolSnapshotViem, computeMarketDepthBands, simulateVaultWithdraw } from 'liquidity-meter'`
+  - CLI subpath: `node ./node_modules/liquidity-meter/dist/cli/liquidity-depth.js --help`
+
+Quick Start
+
+- Single pool (on-chain via Tevm fork):
+  - `liquidity-depth --pool 0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8 --rpc https://mainnet.infura.io/v3/<KEY>`
+- Same with JSON output:
+  - `liquidity-depth --pool 0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8 --rpc <URL> --json`
+- Subgraph fallback:
+  - `liquidity-depth --pool 0x... --source subgraph`
+
+- Single pool with withdraw simulation (Tevm fork):
+  - `liquidity-depth --pool 0xPOOL --vault 0xVAULT --owner 0xOWNER --withdraw-pct 25 --rpc https://developer-access-mainnet.base.org --usd-sizes 1000,5000,10000`
+
+Tevm (On-Chain Fork)
+
+- Default source is `tevm`. The tool forks at `latest` from `--rpc` and reads the pool directly.
+- We suppress EVM logs in reports and mine blocks deterministically for post-action state.
+- If you see “distance to target block exceeds maximum proof window,” use a provider with proof support or a more recent block (we default to `latest`).
+
+Batch via CSV
+
+- Run the CLI over many pools and write a per-pool report:
+  - `liquidity-depth --csv "/path/to/file.csv" --outdir ./reports --rpc <URL>`
+  - Reliability flags for large batches / flaky providers:
+    - `--throttle-ms N` add delay between rows and retries
+    - `--retries N` retry transient JSON-RPC failures (e.g., `-32000`, proof window, `429`)
+- CSV header expectations:
+  - Pool address: prefer one of `pool`, `address`, `pool_address`, `id` (addresses embedded in URLs are auto-detected).
+  - If no pool address is present, provide `token0`, `token1`, and `fee`, and with `--rpc` the tool will resolve the pool using the Uniswap v3 factory.
+  - Optional per-row overrides: `rpc`, `source`, `percent`, `token0_usd`, `token1_usd`, `usd_sizes`, `assume_stable`, `prices`.
+  - Steer vault simulation columns (optional):
+    - `vault` (aliases: `vault_address`, `vault address`, `strategy`)
+    - `owner` (aliases: `owner_address`, `owner address`, `withdraw_owner`, `account`, `user`, `recipient`, `to`)
+    - `withdraw_pct` (aliases: `withdraw percent`, `withdraw_percent`, `withdrawPercentage`, `withdrawPercent`, `pct_withdraw`, `percent_withdraw`)
+    - `withdraw_shares` (aliases: `withdraw shares`, `withdrawShares`, `shares_to_withdraw`, `withdraw_share_amount`)
+- Output:
+  - Writes one file per pool in `--outdir` (default `reports`), named `<pool>.txt` or `<pool>.json` when `--json` is set.
+
+CSV example
+
+```
+pool,vault,owner,withdraw_pct,usd_sizes
+0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8,0xYourVault,0xYourOwner,25,"1000,5000,10000"
+```
+
+Simulating Steer Vault Withdrawals (Before/After)
+
+- Adds an “after” section by impersonating an owner on a Tevm fork, withdrawing shares from the Steer vault, mining, then re-running the analysis.
+- Global flags:
+  - `--vault <VAULT_ADDRESS>`: Vault to withdraw from (per-row CSV overrides supported).
+  - `--owner <ADDRESS>`: Address whose shares are withdrawn (or env `OWNER`).
+  - `--withdraw-pct <N>`: Percent of owner’s current share balance to withdraw (e.g., 25).
+  - `--withdraw-shares <RAW>`: Raw share amount (overrides percent).
+- The withdraw is simulated on the fork only. We top up owner gas, impersonate the owner, call `withdraw(shares,0,0,owner)`, then mine 1 block.
+- Example (CSV with a `vault` column):
+  - `OWNER=0xYourOwner liquidity-depth --csv "/path/file.csv" --outdir ./reports --rpc <URL> --withdraw-pct 25`
+
+Debug logging for withdraws
+
+- Pass `--debug` to print a concise audit trail to stderr without polluting report files:
+  - Planned shares and percent, owner’s current shares and vault total supply.
+  - Owner and vault token balances before/after (formatted with decimals + symbol).
+  - Owner deltas received for token0/token1.
+  - Transaction hash on submit, then `[after]` changes to tick and in-range liquidity.
+  - A pool mismatch notice if `vault.pool()` differs from CLI `--pool`.
+
+Text Output (Summary)
+
+- Shows pool, token symbols/addresses, tick, fee, inferred or fetched USD prices, range of examined ticks, cumulative USD depth per bucket, headline ±2% depth, and optional price impact lines for USD sizes.
+- If a withdrawal is simulated, an “— After Withdraw —” section prints the same summary after state changes.
+
+JSON Output
+
+- Without simulation: prints a single object with fields:
+  - `pool`, `tokens.token0/1`, `ethPriceUSD`, `tick`, `sqrtPriceX96`, `liquidity`, `feePips`, `range`, `percentBuckets`, `prices`, `buyCumToken1[]`, `sellCumToken0[]`, and metrics from `computeMarketDepthBands` plus optional `priceImpacts`.
+- With simulation: prints `{ before: {...}, after: {...} }` with the same structure on each side. BigInts are stringified in arrays.
+
+Options (Reference)
+
+- `--pool` / `-p`: Uniswap v3 pool address.
+- `--percent` / `-b`: Comma-separated percent buckets (default: `1,2,5,10`).
+- `--source`: `tevm|subgraph|auto` (default: `tevm`).
+- `--rpc` / `-r`: RPC URL for Tevm fork (or env `RPC_URL`).
+- `--subgraph` / `-s`: Subgraph URL (defaults to Uniswap v3 mainnet).
+- `--token0-usd` / `--token1-usd`: Manual USD prices.
+- `--assume-stable 0|1`: Assume token index is $1 stable when USD not supplied/inferred.
+- `--usd-sizes`: Comma-separated USD sizes for price impact (token1 buys, token0 sells).
+- `--prices`: `reserve|dexscreener|llama|coingecko|auto` (default: `auto`; env `PRICES_SOURCE`).
+- `--reserve-limit`: Limit for Reserve API (default: `100`; env `RESERVE_LIMIT`).
+- `--throttle-ms`: Delay between CSV rows & retries (ms).
+- `--retries`: Retries per row on transient RPC errors (default: `0`).
+- `--csv`: CSV file with pool/vault rows.
+- `--outdir`: Output directory (default: `reports`).
+- `--json` / `-j`: Emit machine-readable JSON.
+- `--debug`: Print pricing/inference debug logs to stderr.
+- `--vault`, `--owner`, `--withdraw-pct`, `--withdraw-shares`: Steer vault withdraw simulation (see above).
+
+Pricing Sources
+
+- If manual USD prices aren’t provided, the tool tries (in `auto` mode): Reserve (if chainId known), Dexscreener (if chainId known), DeFiLlama, Coingecko.
+- ChainId is resolved via the provided RPC. Coingecko can be rate-limited without an API key.
+
+RPC Guidance (Proof Window)
+
+- Tevm forks and then reads state using proofs from your RPC. Some providers only serve proofs for a recent block window.
+- If you see: “distance to target block exceeds maximum proof window,” switch to a proof-capable provider or ensure you fork at `latest` (default).
+- Recommended for Base: `https://developer-access-mainnet.base.org`.
+
+Troubleshooting
+
+- Missing `--rpc` in tevm mode: supply `--rpc` or set `RPC_URL`.
+- CSV row errors write a file named `error-<pool>.txt` in `--outdir`.
+- If owner has 0 vault shares at the forked block, the withdraw step is skipped.
+- If a vault does not expose `pool()` or withdraw reverts, the run fails for that row only.
+- Logs: Reports strip noisy EVM logs; use `--debug` for pricing diagnostics.
+- zsh/newlines: keep command arguments on a single line (e.g., do not split `--rpc` URL across lines).
+
+Examples
+
+- Single pool on-chain:
+  - `liquidity-depth --pool 0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8 --rpc https://mainnet.infura.io/v3/<KEY> --usd-sizes 1000,5000,10000`
+- Batch CSV:
+  - `liquidity-depth --csv "/path/to/file.csv" --outdir ./reports --rpc https://developer-access-mainnet.base.org --usd-sizes 1000,5000,10000,25000,50000,100000`
+  - With backoff and retries:
+    - `liquidity-depth --csv "/path/to/file.csv" --outdir ./reports --rpc https://developer-access-mainnet.base.org --usd-sizes 1000,5000,10000,25000,50000,100000 --throttle-ms 500 --retries 2`
+- Batch with withdraw simulation for a single owner across all rows:
+  - `OWNER=0xYourOwner liquidity-depth --csv "/path/to/file.csv" --outdir ./reports --rpc https://developer-access-mainnet.base.org --withdraw-pct 25 --usd-sizes 1000,5000,10000`
+
+Programmatic API
+
+- One-call analysis (before/after) with price inference and optional withdraw simulation:
+
+```
+import { analyzePool } from 'liquidity-meter'
+
+const res = await analyzePool({
+  poolAddress: '0x11e26bbd1a5547895a50fc39a2d4c0025dec0bda',
+  source: 'tevm',                          // or 'subgraph' | 'auto'
+  rpcUrl: 'https://developer-access-mainnet.base.org',
+  percentBuckets: [1, 2, 5, 10],
+  usdSizes: [1000, 5000, 10000, 25000],
+  prices: 'auto',                          // reserve | dexscreener | llama | coingecko | auto
+  withdraw: {                              // optional; TEVM only
+    vault: '0xYourVault',
+    owner: '0xYourOwner',
+    withdrawPct: 25,                       // or: withdrawShares: '1230000000000000000'
+  },
+})
+
+console.log(res.before.metrics.depthPlus2USD)
+console.log(res.after?.metrics.depthPlus2USD)
+```
+
+- Lower-level building blocks (for custom flows):
+
+```
+import {
+  fetchPoolSnapshotViem,                 // TEVM on-chain snapshot
+  fetchPoolSnapshot as fetchFromSubgraph,
+  computeMarketDepthBands,
+  computePriceImpactsBySizes,
+  fetchTokenUSDPrices,
+  simulateVaultWithdraw,                 // TEVM withdraw sim
+} from 'liquidity-meter'
+```
+
+Notes & Limitations
+
+- No transactions are sent to mainnet; all simulations run on a local fork.
+- Certain deposit transaction types (e.g., EIP-7702/OP Stack deposits) may be filtered in forked blocks; this does not affect pool state reads.
+- The tool does not model MEV or off-range liquidity changes between snapshots.
+
+Templates
+
+- This repo includes ready-to-edit CSV templates under `templates/`:
+  - `templates/pools_minimal.csv`
+  - `templates/pools_with_vault.csv`
+- Copy one and fill in your addresses, then run (example):
+  - `liquidity-depth --csv ./templates/pools_with_vault.csv --outdir ./reports --rpc https://developer-access-mainnet.base.org`

package/dist/adapters/onchain.d.ts

@@ -0,0 +1,51 @@
+import { createMemoryClient } from 'tevm';
+import { Tick } from '../core/depth.js';
+export type PoolSnapshotOnchain = {
+    sqrtPriceX96: bigint;
+    tick: number;
+    liquidity: bigint;
+    feePips: number;
+    ticks: Tick[];
+    token0: {
+        decimals: number;
+        usdPrice: number;
+        id?: string;
+        symbol?: string;
+    };
+    token1: {
+        decimals: number;
+        usdPrice: number;
+        id?: string;
+        symbol?: string;
+    };
+    meta: {
+        token0: {
+            decimals: number;
+            id: string;
+            symbol?: string;
+        };
+        token1: {
+            decimals: number;
+            id: string;
+            symbol?: string;
+        };
+        poolId: string;
+        range: {
+            start: number;
+            end: number;
+        };
+        farPercent: number;
+        tickSpacing: number;
+    };
+};
+export declare function fetchPoolSnapshotViem(params: {
+    poolAddress: string;
+    rpcUrl?: string;
+    percentBuckets?: number[];
+    client?: ReturnType<typeof createMemoryClient>;
+}): Promise<PoolSnapshotOnchain>;
+export declare function fetchPoolSnapshotCore(params: {
+    poolAddress: string;
+    rpcUrl: string;
+    percentBuckets?: number[];
+}): Promise<PoolSnapshotOnchain>;

package/dist/adapters/onchain.js

@@ -0,0 +1,158 @@
+// On-chain fetcher for Uniswap v3 pools (TypeScript)
+import { createMemoryClient, http } from 'tevm';
+import { getAddress } from 'viem';
+import { readContract } from '@wagmi/core';
+import { configFromRpc } from '../wagmi/config.js';
+import { erc20Abi, uniswapV3PoolAbi } from '../wagmi/generated.js';
+// ABIs sourced from wagmi CLI generated file
+function percentToTickDelta(pct) {
+    const r = 1 + pct / 100;
+    const delta = Math.log(r) / Math.log(1.0001);
+    return Math.max(1, Math.round(delta));
+}
+function floorDiv(a, b) {
+    const q = Math.trunc(a / b);
+    const r = a % b;
+    return (r !== 0 && ((r > 0) !== (b > 0))) ? q - 1 : q;
+}
+export async function fetchPoolSnapshotViem(params) {
+    const { poolAddress, rpcUrl, percentBuckets = [1, 2, 5, 10], client } = params;
+    let c = client;
+    if (!c) {
+        if (!rpcUrl)
+            throw new Error('rpcUrl required when client is not provided');
+        c = createMemoryClient({ fork: { transport: http(rpcUrl), blockTag: 'latest' }, loggingLevel: 'error' });
+        if (c.tevmReady)
+            await c.tevmReady();
+    }
+    const pool = getAddress(poolAddress);
+    const [slot0Raw, LRaw, feeRaw, spacingRaw, token0Addr, token1Addr] = await Promise.all([
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'slot0' }),
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'liquidity' }),
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'fee' }),
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'tickSpacing' }),
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'token0' }),
+        c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'token1' }),
+    ]);
+    const [dec0, sym0, dec1, sym1] = await Promise.all([
+        c.readContract({ address: token0Addr, abi: erc20Abi, functionName: 'decimals' }),
+        c.readContract({ address: token0Addr, abi: erc20Abi, functionName: 'symbol' }),
+        c.readContract({ address: token1Addr, abi: erc20Abi, functionName: 'decimals' }),
+        c.readContract({ address: token1Addr, abi: erc20Abi, functionName: 'symbol' }),
+    ]);
+    const sqrtPriceX96 = slot0Raw[0];
+    const tick = Number(slot0Raw[1]);
+    const liquidity = LRaw;
+    const feePips = Number(feeRaw);
+    const tickSpacing = Number(spacingRaw);
+    const far = Math.max(...percentBuckets);
+    const delta = percentToTickDelta(far);
+    const start = tick - delta;
+    const end = tick + delta;
+    const compStart = floorDiv(start, tickSpacing);
+    const compEnd = floorDiv(end, tickSpacing);
+    const wordStart = floorDiv(compStart, 256);
+    const wordEnd = floorDiv(compEnd, 256);
+    const ticks = [];
+    for (let w = wordStart; w <= wordEnd; w++) {
+        const bitmap = await c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'tickBitmap', args: [BigInt(w)] });
+        if (bitmap === 0n)
+            continue;
+        for (let bit = 0; bit < 256; bit++) {
+            if (((bitmap >> BigInt(bit)) & 1n) === 0n)
+                continue;
+            const compressed = w * 256 + bit;
+            const t = compressed * tickSpacing;
+            if (t < start || t > end)
+                continue;
+            const ret = await c.readContract({ address: pool, abi: uniswapV3PoolAbi, functionName: 'ticks', args: [t] });
+            const liquidityNet = ret[1];
+            ticks.push({ index: t, liquidityNet });
+        }
+    }
+    return {
+        sqrtPriceX96,
+        tick,
+        liquidity,
+        feePips,
+        ticks: ticks.sort((a, b) => a.index - b.index),
+        token0: { decimals: Number(dec0), usdPrice: 0, symbol: sym0, id: token0Addr },
+        token1: { decimals: Number(dec1), usdPrice: 0, symbol: sym1, id: token1Addr },
+        meta: {
+            token0: { decimals: Number(dec0), symbol: sym0, id: token0Addr },
+            token1: { decimals: Number(dec1), symbol: sym1, id: token1Addr },
+            poolId: pool,
+            range: { start, end },
+            farPercent: far,
+            tickSpacing,
+        },
+    };
+}
+// Fetch using wagmi/core actions (no TEVM), talking directly to RPC
+export async function fetchPoolSnapshotCore(params) {
+    const { poolAddress, rpcUrl, percentBuckets = [1, 2, 5, 10] } = params;
+    const cfg = await configFromRpc(rpcUrl);
+    const chainId = cfg.chains[0].id;
+    const pool = getAddress(poolAddress);
+    const [slot0Raw, LRaw, feeRaw, spacingRaw, token0Addr, token1Addr] = await Promise.all([
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'slot0', chainId }),
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'liquidity', chainId }),
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'fee', chainId }),
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'tickSpacing', chainId }),
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'token0', chainId }),
+        readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'token1', chainId }),
+    ]);
+    const [dec0, sym0, dec1, sym1] = await Promise.all([
+        readContract(cfg, { address: token0Addr, abi: erc20Abi, functionName: 'decimals', chainId }),
+        readContract(cfg, { address: token0Addr, abi: erc20Abi, functionName: 'symbol', chainId }),
+        readContract(cfg, { address: token1Addr, abi: erc20Abi, functionName: 'decimals', chainId }),
+        readContract(cfg, { address: token1Addr, abi: erc20Abi, functionName: 'symbol', chainId }),
+    ]);
+    const sqrtPriceX96 = slot0Raw[0];
+    const tick = Number(slot0Raw[1]);
+    const liquidity = LRaw;
+    const feePips = Number(feeRaw);
+    const tickSpacing = Number(spacingRaw);
+    const far = Math.max(...percentBuckets);
+    const delta = percentToTickDelta(far);
+    const start = tick - delta;
+    const end = tick + delta;
+    const compStart = floorDiv(start, tickSpacing);
+    const compEnd = floorDiv(end, tickSpacing);
+    const wordStart = floorDiv(compStart, 256);
+    const wordEnd = floorDiv(compEnd, 256);
+    const ticks = [];
+    for (let w = wordStart; w <= wordEnd; w++) {
+        const bitmap = (await readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'tickBitmap', args: [BigInt(w)], chainId }));
+        if (bitmap === 0n)
+            continue;
+        for (let bit = 0; bit < 256; bit++) {
+            if (((bitmap >> BigInt(bit)) & 1n) === 0n)
+                continue;
+            const compressed = w * 256 + bit;
+            const t = compressed * tickSpacing;
+            if (t < start || t > end)
+                continue;
+            const ret = (await readContract(cfg, { address: pool, abi: uniswapV3PoolAbi, functionName: 'ticks', args: [t], chainId }));
+            const liquidityNet = ret[1];
+            ticks.push({ index: t, liquidityNet });
+        }
+    }
+    return {
+        sqrtPriceX96,
+        tick,
+        liquidity,
+        feePips,
+        ticks: ticks.sort((a, b) => a.index - b.index),
+        token0: { decimals: Number(dec0), usdPrice: 0, symbol: sym0, id: token0Addr },
+        token1: { decimals: Number(dec1), usdPrice: 0, symbol: sym1, id: token1Addr },
+        meta: {
+            token0: { decimals: Number(dec0), symbol: sym0, id: token0Addr },
+            token1: { decimals: Number(dec1), symbol: sym1, id: token1Addr },
+            poolId: pool,
+            range: { start, end },
+            farPercent: far,
+            tickSpacing,
+        },
+    };
+}

package/dist/adapters/uniswapv3-subgraph.d.ts

@@ -0,0 +1,44 @@
+import { Tick } from '../core/depth.js';
+export type PoolSnapshot = {
+    sqrtPriceX96: bigint;
+    tick: number;
+    liquidity: bigint;
+    feePips: number;
+    ticks: Tick[];
+    token0: {
+        decimals: number;
+        usdPrice: number;
+        id?: string;
+        symbol?: string;
+    };
+    token1: {
+        decimals: number;
+        usdPrice: number;
+        id?: string;
+        symbol?: string;
+    };
+    meta: {
+        token0?: {
+            decimals: number;
+            id: string;
+            symbol?: string;
+        };
+        token1?: {
+            decimals: number;
+            id: string;
+            symbol?: string;
+        };
+        ethPriceUSD?: number;
+        poolId: string;
+        range: {
+            start: number;
+            end: number;
+        };
+        farPercent: number;
+    };
+};
+export declare function fetchPoolSnapshot(params: {
+    poolAddress: string;
+    percentBuckets?: number[];
+    subgraphUrl?: string;
+}): Promise<PoolSnapshot>;

package/dist/adapters/uniswapv3-subgraph.js

@@ -0,0 +1,105 @@
+// Uniswap v3 subgraph client (TypeScript)
+import axios from 'axios';
+import { DepthInternals } from '../core/depth.js';
+const DEFAULT_SUBGRAPH = 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3';
+function percentToTickDelta(pct) {
+    const r = 1 + pct / 100;
+    const delta = Math.log(r) / Math.log(1.0001);
+    return Math.max(1, Math.round(delta));
+}
+async function graphqlFetch(url, query, variables) {
+    const res = await axios.post(url, { query, variables }, {
+        headers: { 'content-type': 'application/json' },
+        maxRedirects: 5,
+        timeout: 15000,
+        validateStatus: (s) => s >= 200 && s < 300,
+    });
+    const body = res.data;
+    if (body.errors && body.errors.length) {
+        const msg = body.errors.map((e) => e.message).join('; ');
+        throw new Error(`Subgraph error: ${msg}`);
+    }
+    return body.data;
+}
+export async function fetchPoolSnapshot(params) {
+    const { poolAddress, percentBuckets = [1, 2, 5, 10], subgraphUrl = DEFAULT_SUBGRAPH } = params;
+    const id = poolAddress.toLowerCase();
+    const coreQuery = `
+    query PoolCore($id: ID!) {
+      bundle(id: "1") { ethPriceUSD }
+      pool(id: $id) {
+        id
+        sqrtPrice
+        tick
+        liquidity
+        feeTier
+        token0 { id symbol decimals derivedETH }
+        token1 { id symbol decimals derivedETH }
+      }
+    }
+  `;
+    const core = await graphqlFetch(subgraphUrl, coreQuery, { id });
+    if (!core.pool)
+        throw new Error(`Pool not found in subgraph: ${id}`);
+    const ethPriceUSD = Number(core.bundle?.ethPriceUSD ?? 0);
+    const pool = core.pool;
+    const sqrtPriceX96 = BigInt(pool.sqrtPrice);
+    const tick = Number(pool.tick);
+    const liquidity = BigInt(pool.liquidity);
+    const feePips = Number(pool.feeTier);
+    const token0 = {
+        decimals: Number(pool.token0.decimals),
+        usdPrice: Number(pool.token0.derivedETH) * ethPriceUSD,
+        symbol: pool.token0.symbol,
+        id: pool.token0.id,
+    };
+    const token1 = {
+        decimals: Number(pool.token1.decimals),
+        usdPrice: Number(pool.token1.derivedETH) * ethPriceUSD,
+        symbol: pool.token1.symbol,
+        id: pool.token1.id,
+    };
+    const far = Math.max(...percentBuckets);
+    const delta = percentToTickDelta(far);
+    const start = Math.max(DepthInternals.MIN_TICK, tick - delta);
+    const end = Math.min(DepthInternals.MAX_TICK, tick + delta);
+    const ticks = [];
+    const pageSize = 1000;
+    let skip = 0;
+    while (true) {
+        const ticksQuery = `
+      query PoolTicks($id: ID!, $start: Int!, $end: Int!, $first: Int!, $skip: Int!) {
+        pool(id: $id) {
+          ticks(where: { tickIdx_gte: $start, tickIdx_lte: $end }, orderBy: tickIdx, orderDirection: asc, first: $first, skip: $skip) {
+            tickIdx
+            liquidityNet
+          }
+        }
+      }
+    `;
+        const data = await graphqlFetch(subgraphUrl, ticksQuery, { id, start, end, first: pageSize, skip });
+        const page = data.pool?.ticks ?? [];
+        for (const t of page)
+            ticks.push({ index: Number(t.tickIdx), liquidityNet: BigInt(t.liquidityNet) });
+        if (page.length < pageSize)
+            break;
+        skip += pageSize;
+    }
+    return {
+        sqrtPriceX96,
+        tick,
+        liquidity,
+        feePips,
+        ticks,
+        token0: { decimals: token0.decimals, usdPrice: token0.usdPrice, id: token0.id, symbol: token0.symbol },
+        token1: { decimals: token1.decimals, usdPrice: token1.usdPrice, id: token1.id, symbol: token1.symbol },
+        meta: {
+            token0: { decimals: token0.decimals, id: token0.id, symbol: token0.symbol },
+            token1: { decimals: token1.decimals, id: token1.id, symbol: token1.symbol },
+            ethPriceUSD,
+            poolId: id,
+            range: { start, end },
+            farPercent: far,
+        },
+    };
+}

package/dist/adapters/withdraw.d.ts

@@ -0,0 +1,14 @@
+import { createMemoryClient } from 'tevm';
+export type WithdrawParams = {
+    client: ReturnType<typeof createMemoryClient>;
+    vault: string;
+    owner: string;
+    withdrawPct?: number;
+    withdrawShares?: string | number | bigint;
+    debug?: boolean;
+    cliPool?: string;
+    viemChain?: any;
+};
+export declare function simulateVaultWithdraw(params: WithdrawParams): Promise<boolean>;
+export declare function resolveViemChainFromClient(client: any): Promise<any>;
+export declare function resolveTevmCommon(rpcUrl?: string): Promise<any>;