@steerprotocol/liquidity-meter 1.0.0 → 2.0.0

package/src/uniswapv3-subgraph.js

@@ -0,0 +1,141 @@
+// Uniswap v3 subgraph client (axios-based)
+// Pulls pool snapshot and ticks in a target range.
+
+import { DepthInternals } from './depth.js';
+import axios from 'axios';
+
+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) {
+    const msg = body.errors.map((e) => e.message).join('; ');
+    throw new Error(`Subgraph error: ${msg}`);
+  }
+  return body.data;
+}
+
+export async function fetchPoolSnapshot({
+  poolAddress,
+  percentBuckets = [1, 2, 5, 10],
+  subgraphUrl = DEFAULT_SUBGRAPH,
+  blockNumber,
+}) {
+  const id = poolAddress.toLowerCase();
+  let blockVar = null;
+  if (blockNumber !== undefined && blockNumber !== null) {
+    const bn = typeof blockNumber === 'bigint' ? blockNumber : BigInt(blockNumber);
+    if (bn < 0n) throw new Error('Block number must be non-negative');
+    const asNumber = Number(bn);
+    if (!Number.isFinite(asNumber)) throw new Error('Block number is too large for subgraph query');
+    blockVar = { number: asNumber };
+  }
+
+  // First fetch pool core fields + ETH price
+  const coreQuery = `
+    query PoolCore($id: ID!, $block: Block_height) {
+      bundle(id: "1", block: $block) { ethPriceUSD }
+      pool(id: $id, block: $block) {
+        id
+        sqrtPrice
+        tick
+        liquidity
+        feeTier
+        token0 { id symbol decimals derivedETH }
+        token1 { id symbol decimals derivedETH }
+      }
+    }
+  `;
+
+  const core = await graphqlFetch(subgraphUrl, coreQuery, { id, block: blockVar });
+  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,
+  };
+
+  // Determine tick bounds for the farthest bucket
+  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);
+
+  // Paginate ticks in [start, end]
+  const ticks = [];
+  const pageSize = 1000;
+  let skip = 0;
+  while (true) {
+    const ticksQuery = `
+      query PoolTicks($id: ID!, $start: Int!, $end: Int!, $first: Int!, $skip: Int!, $block: Block_height) {
+        pool(id: $id, block: $block) {
+          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,
+      block: blockVar,
+    });
+    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 },
+    token1: { decimals: token1.decimals, usdPrice: token1.usdPrice },
+    meta: {
+      token0,
+      token1,
+      ethPriceUSD,
+      poolId: id,
+      range: { start, end },
+      farPercent: far,
+      blockNumber: blockVar?.number ?? undefined,
+    },
+  };
+}

package/src/viem-onchain.js

@@ -0,0 +1,233 @@
+// On-chain fetcher for Uniswap v3 pools using a viem public client
+// - Reads pool slot0, liquidity, fee, tickSpacing, token0/1 addresses + ERC20 decimals/symbols
+// - Enumerates initialized ticks via tickBitmap within a bounded range
+
+import { createPublicClient, getAddress, http, parseAbi } from 'viem';
+
+const UNISWAP_POOL_ABI = parseAbi([
+  'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)',
+  'function liquidity() view returns (uint128)',
+  'function fee() view returns (uint24)',
+  'function tickSpacing() view returns (int24)',
+  'function token0() view returns (address)',
+  'function token1() view returns (address)',
+  'function tickBitmap(int16) view returns (uint256)',
+  'function ticks(int24 tick) view returns (uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)'
+]);
+
+const ALGEBRA_POOL_ABI = parseAbi([
+  'function liquidity() view returns (uint128)',
+  'function tickSpacing() view returns (int24)',
+  'function token0() view returns (address)',
+  'function token1() view returns (address)',
+  'function tickTable(int16) view returns (uint256)',
+  'function ticks(int24 tick) view returns (uint256 liquidityTotal, int128 liquidityDelta, int24 prevTick, int24 nextTick, uint256 outerFeeGrowth0Token, uint256 outerFeeGrowth1Token)'
+]);
+
+const ERC20_ABI = parseAbi([
+  'function decimals() view returns (uint8)',
+  'function symbol() view returns (string)'
+]);
+
+const GLOBAL_STATE_SELECTOR = '0xe76c01e4';
+const TWO_256 = 1n << 256n;
+const TWO_255 = 1n << 255n;
+
+function toSigned256(x) {
+  return x >= TWO_255 ? x - TWO_256 : x;
+}
+
+function decodeAlgebraGlobalState(hexData) {
+  if (!hexData || hexData === '0x') {
+    throw new Error('Empty globalState response');
+  }
+  const clean = hexData.slice(2);
+  const words = [];
+  for (let i = 0; i < clean.length; i += 64) {
+    const chunk = clean.slice(i, i + 64);
+    if (chunk.length === 0) break;
+    words.push(BigInt('0x' + chunk));
+  }
+  if (words.length < 2) {
+    throw new Error('Unexpected globalState payload');
+  }
+  const sqrtPriceX96 = words[0];
+  const tickBig = toSigned256(words[1]);
+  const feeWord = words[2] ?? 0n;
+  const tick = Number(tickBig);
+  if (!Number.isSafeInteger(tick)) {
+    throw new Error('Decoded Algebra tick is not a safe integer');
+  }
+  const feePips = Number(feeWord);
+  return { sqrtPriceX96, tick, feePips };
+}
+
+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({ poolAddress, rpcUrl, percentBuckets = [1,2,5,10], client, blockTag = 'latest' }) {
+  let c = client;
+  if (!c) {
+    c = createPublicClient({ transport: http(rpcUrl) });
+  }
+  const pool = getAddress(poolAddress);
+  const readBlockParams =
+    typeof blockTag === 'bigint'
+      ? { blockNumber: blockTag }
+      : typeof blockTag === 'number'
+        ? { blockNumber: BigInt(blockTag) }
+        : blockTag && blockTag !== 'latest'
+          ? { blockTag }
+          : {};
+
+  let resolvedBlockNumber;
+  let resolvedBlockTimestamp;
+  try {
+    const blk = await c.getBlock(
+      'blockNumber' in readBlockParams || 'blockTag' in readBlockParams
+        ? readBlockParams
+        : { blockTag: 'latest' }
+    );
+    if (blk) {
+      resolvedBlockNumber = blk.number;
+      resolvedBlockTimestamp = blk.timestamp;
+    }
+  } catch (_) {
+    try {
+      resolvedBlockNumber = await c.getBlockNumber();
+    } catch (_) {}
+  }
+
+  let sqrtPriceX96;
+  let tick;
+  let liquidity;
+  let feePips;
+  let tickSpacing;
+  let token0Addr;
+  let token1Addr;
+  let poolType = 'uniswap';
+
+  try {
+    const [slot0, L, fee, spacing, tok0, tok1] = await Promise.all([
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'slot0', ...readBlockParams }),
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'liquidity', ...readBlockParams }),
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'fee', ...readBlockParams }),
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'tickSpacing', ...readBlockParams }),
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'token0', ...readBlockParams }),
+      c.readContract({ address: pool, abi: UNISWAP_POOL_ABI, functionName: 'token1', ...readBlockParams }),
+    ]);
+    sqrtPriceX96 = slot0[0];
+    tick = Number(slot0[1]);
+    liquidity = L;
+    feePips = Number(fee);
+    tickSpacing = Number(spacing);
+    token0Addr = tok0;
+    token1Addr = tok1;
+  } catch (uniswapErr) {
+    poolType = 'algebra';
+    let globalState;
+    try {
+      const callResult = await c.transport.request({
+        method: 'eth_call',
+        params: [
+          { to: pool, data: GLOBAL_STATE_SELECTOR },
+          typeof blockTag === 'bigint'
+            ? `0x${blockTag.toString(16)}`
+            : typeof blockTag === 'number'
+              ? `0x${blockTag.toString(16)}`
+              : blockTag ?? 'latest',
+        ],
+      });
+      globalState = decodeAlgebraGlobalState(callResult);
+    } catch (algebraStateErr) {
+      const combined = new Error(`Failed to read pool state as Uniswap (slot0): ${uniswapErr?.message || uniswapErr}. Algebra globalState call also failed: ${algebraStateErr?.message || algebraStateErr}`);
+      combined.cause = { uniswap: uniswapErr, algebra: algebraStateErr };
+      throw combined;
+    }
+    const [L, spacing, tok0, tok1] = await Promise.all([
+      c.readContract({ address: pool, abi: ALGEBRA_POOL_ABI, functionName: 'liquidity', ...readBlockParams }),
+      c.readContract({ address: pool, abi: ALGEBRA_POOL_ABI, functionName: 'tickSpacing', ...readBlockParams }),
+      c.readContract({ address: pool, abi: ALGEBRA_POOL_ABI, functionName: 'token0', ...readBlockParams }),
+      c.readContract({ address: pool, abi: ALGEBRA_POOL_ABI, functionName: 'token1', ...readBlockParams }),
+    ]);
+    sqrtPriceX96 = globalState.sqrtPriceX96;
+    tick = globalState.tick;
+    liquidity = L;
+    feePips = globalState.feePips;
+    tickSpacing = Number(spacing);
+    token0Addr = tok0;
+    token1Addr = tok1;
+  }
+
+  tickSpacing = Math.abs(Number(tickSpacing));
+  if (!tickSpacing) {
+    throw new Error('tickSpacing resolved to zero');
+  }
+
+  const [dec0, sym0, dec1, sym1] = await Promise.all([
+    c.readContract({ address: token0Addr, abi: ERC20_ABI, functionName: 'decimals', ...readBlockParams }),
+    c.readContract({ address: token0Addr, abi: ERC20_ABI, functionName: 'symbol', ...readBlockParams }),
+    c.readContract({ address: token1Addr, abi: ERC20_ABI, functionName: 'decimals', ...readBlockParams }),
+    c.readContract({ address: token1Addr, abi: ERC20_ABI, functionName: 'symbol', ...readBlockParams }),
+  ]);
+
+  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 = [];
+  const poolAbi = poolType === 'algebra' ? ALGEBRA_POOL_ABI : UNISWAP_POOL_ABI;
+  const bitmapFn = poolType === 'algebra' ? 'tickTable' : 'tickBitmap';
+  for (let w = wordStart; w <= wordEnd; w++) {
+    // tickBitmap index is int16
+    const bitmap = await c.readContract({ address: pool, abi: poolAbi, functionName: bitmapFn, args: [BigInt(w)], ...readBlockParams });
+    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;
+      // Read tick data to get liquidityNet
+      const ret = await c.readContract({ address: pool, abi: poolAbi, functionName: 'ticks', args: [t], ...readBlockParams });
+      const liquidityNet = ret[1];
+      ticks.push({ index: t, liquidityNet: 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,
+      poolType,
+      blockNumber: resolvedBlockNumber,
+      blockTimestamp: resolvedBlockTimestamp,
+      blockTag,
+    },
+  };
+}

package/src/withdraw.js

@@ -0,0 +1,333 @@
+import {
+  createPublicClient,
+  encodeFunctionData,
+  getAddress,
+  http as viemHttp,
+  parseAbi,
+  parseEther,
+} from 'viem';
+import { sendTransaction as viemSendTransaction } from 'viem/actions';
+
+const ERC20_ABI = parseAbi([
+  'function balanceOf(address) view returns (uint256)',
+  'function decimals() view returns (uint8)',
+  'function symbol() view returns (string)',
+  'function totalSupply() view returns (uint256)',
+]);
+
+const VAULT_ABI = parseAbi([
+  'function pool() view returns (address)',
+  'function token0() view returns (address)',
+  'function token1() view returns (address)',
+  'function decimals() view returns (uint8)',
+  'function withdraw(uint256 shares,uint256 amount0Min,uint256 amount1Min,address to) returns (uint256 amount0,uint256 amount1)',
+]);
+
+function formatUnits(value, decimals) {
+  try {
+    let normalized = BigInt(value);
+    const negative = normalized < 0n;
+    if (negative) normalized = -normalized;
+    const stringified = normalized
+      .toString()
+      .padStart(Number(decimals) + 1, '0');
+    const integer = stringified.slice(0, stringified.length - Number(decimals));
+    const fraction = stringified
+      .slice(stringified.length - Number(decimals))
+      .replace(/0+$/, '')
+      .slice(0, 8);
+    return `${negative ? '-' : ''}${integer}${fraction ? `.${fraction}` : ''}`;
+  } catch (_) {
+    return String(value);
+  }
+}
+
+function formatToken(value, decimals, symbol) {
+  return `${formatUnits(value, decimals)} ${symbol || ''}`.trim();
+}
+
+export async function createForkClient({ rpcUrl, blockTag = 'latest' }) {
+  const { createMemoryClient, http } = await import('tevm');
+  const client = createMemoryClient({
+    fork: { transport: http(rpcUrl), blockTag },
+    loggingLevel: 'error',
+  });
+  if (client.tevmReady) await client.tevmReady();
+  return client;
+}
+
+export async function resolveTevmCommon(rpcUrl) {
+  try {
+    const tevmCommon = await import('tevm/common');
+    const client = createPublicClient({ transport: viemHttp(rpcUrl) });
+    const chainId = await client.getChainId();
+    for (const value of Object.values(tevmCommon)) {
+      if (value && typeof value === 'object' && 'id' in value && value.id === chainId) {
+        return value;
+      }
+    }
+  } catch (_) {}
+  return undefined;
+}
+
+export async function resolveViemChain(rpcUrl) {
+  try {
+    const viemChains = await import('viem/chains');
+    const client = createPublicClient({ transport: viemHttp(rpcUrl) });
+    const chainId = await client.getChainId();
+    for (const value of Object.values(viemChains)) {
+      if (value && typeof value === 'object' && 'id' in value && value.id === chainId) {
+        return value;
+      }
+    }
+  } catch (_) {}
+  return undefined;
+}
+
+export async function resolveViemChainFromClient(client) {
+  try {
+    const viemChains = await import('viem/chains');
+    const chainId = await client.getChainId();
+    for (const value of Object.values(viemChains)) {
+      if (value && typeof value === 'object' && 'id' in value && value.id === chainId) {
+        return value;
+      }
+    }
+  } catch (_) {}
+  return undefined;
+}
+
+export async function simulateVaultWithdraw({
+  client,
+  vault,
+  owner,
+  withdrawPct,
+  withdrawShares,
+  debug = false,
+  cliPool,
+  viemChain,
+  sendTransaction = viemSendTransaction,
+}) {
+  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 vaultAddress = getAddress(vault);
+  const ownerAddress = getAddress(owner);
+
+  let poolAddress;
+  try {
+    poolAddress = await client.readContract({
+      address: vaultAddress,
+      abi: VAULT_ABI,
+      functionName: 'pool',
+    });
+  } catch (error) {
+    throw new Error(`Failed to read vault.pool(): ${error?.message || error}`);
+  }
+
+  let vaultDecimals = 18;
+  try {
+    vaultDecimals = Number(
+      await client.readContract({
+        address: vaultAddress,
+        abi: VAULT_ABI,
+        functionName: 'decimals',
+      })
+    );
+  } catch (_) {}
+
+  const token0Address = await client.readContract({
+    address: vaultAddress,
+    abi: VAULT_ABI,
+    functionName: 'token0',
+  });
+  const token1Address = await client.readContract({
+    address: vaultAddress,
+    abi: VAULT_ABI,
+    functionName: 'token1',
+  });
+
+  const [token0Decimals, token1Decimals] = await Promise.all([
+    client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'decimals',
+    }),
+    client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'decimals',
+    }),
+  ]);
+
+  let [token0Symbol, token1Symbol] = ['T0', 'T1'];
+  try {
+    token0Symbol = await client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'symbol',
+    });
+  } catch (_) {}
+  try {
+    token1Symbol = await client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'symbol',
+    });
+  } catch (_) {}
+
+  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 balance = await client.readContract({
+      address: vaultAddress,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [ownerAddress],
+    });
+    const pct = BigInt(Math.max(0, Math.min(100, Math.floor(Number(withdrawPct)))));
+    shares = (BigInt(balance) * pct) / 100n;
+  }
+
+  const ownerShares = await client.readContract({
+    address: vaultAddress,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [ownerAddress],
+  });
+  const totalShares = await client.readContract({
+    address: vaultAddress,
+    abi: ERC20_ABI,
+    functionName: 'totalSupply',
+  });
+
+  if (debug) {
+    const poolWarning =
+      cliPool && cliPool.toLowerCase() !== poolAddress.toLowerCase()
+        ? ` (CLI pool=${cliPool})`
+        : '';
+    console.error(
+      `[withdraw] vault=${vaultAddress} pool=${poolAddress}${poolWarning}`
+    );
+    console.error(
+      `[withdraw] owner=${ownerAddress} ownerShares=${formatToken(ownerShares, vaultDecimals, 'shares')} totalSupply=${formatToken(totalShares, vaultDecimals, 'shares')}`
+    );
+    console.error(
+      `[withdraw] planned shares=${formatToken(shares ?? 0n, vaultDecimals, 'shares')} (${Number(withdrawPct ?? 0)}%)`
+    );
+  }
+
+  if (!shares || shares <= 0n) {
+    if (debug) console.error('[withdraw] no shares to withdraw; skipping');
+    return false;
+  }
+
+  try {
+    await client.setBalance({ address: ownerAddress, value: parseEther('0.05') });
+  } catch (_) {}
+  try {
+    await client.impersonateAccount({ address: ownerAddress });
+  } catch (_) {}
+
+  const [owner0Before, owner1Before, vault0Before, vault1Before] = await Promise.all([
+    client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [ownerAddress],
+    }),
+    client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [ownerAddress],
+    }),
+    client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [vaultAddress],
+    }),
+    client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [vaultAddress],
+    }),
+  ]);
+
+  if (debug) {
+    console.error(
+      `[withdraw] owner balances before: ${formatToken(owner0Before, token0Decimals, token0Symbol)}, ${formatToken(owner1Before, token1Decimals, token1Symbol)}`
+    );
+    console.error(
+      `[withdraw] vault  balances before: ${formatToken(vault0Before, token0Decimals, token0Symbol)}, ${formatToken(vault1Before, token1Decimals, token1Symbol)}`
+    );
+  }
+
+  const data = encodeWithdrawData(shares, ownerAddress);
+  const chain = viemChain || (await resolveViemChainFromClient(client));
+  const hash = await sendTransaction(client, {
+    account: ownerAddress,
+    to: vaultAddress,
+    data,
+    chain,
+  });
+  if (debug) console.error(`[withdraw] tx sent: ${hash}`);
+  await client.mine({ blocks: 1 });
+
+  const [owner0After, owner1After, vault0After, vault1After] = await Promise.all([
+    client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [ownerAddress],
+    }),
+    client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [ownerAddress],
+    }),
+    client.readContract({
+      address: token0Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [vaultAddress],
+    }),
+    client.readContract({
+      address: token1Address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [vaultAddress],
+    }),
+  ]);
+
+  if (debug) {
+    console.error(
+      `[withdraw] owner balances after : ${formatToken(owner0After, token0Decimals, token0Symbol)}, ${formatToken(owner1After, token1Decimals, token1Symbol)}`
+    );
+    console.error(
+      `[withdraw] vault  balances after : ${formatToken(vault0After, token0Decimals, token0Symbol)}, ${formatToken(vault1After, token1Decimals, token1Symbol)}`
+    );
+    console.error(
+      `[withdraw] owner deltas: ${formatToken(BigInt(owner0After) - BigInt(owner0Before), token0Decimals, token0Symbol)}, ${formatToken(BigInt(owner1After) - BigInt(owner1Before), token1Decimals, token1Symbol)}`
+    );
+  }
+
+  return true;
+}
+
+function encodeWithdrawData(shares, ownerAddress) {
+  return encodeFunctionData({
+    abi: VAULT_ABI,
+    functionName: 'withdraw',
+    args: [shares, 0n, 0n, ownerAddress],
+  });
+}