@steerprotocol/liquidity-meter 1.0.0

package/dist/adapters/withdraw.js

@@ -0,0 +1,150 @@
+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 { erc20Abi, steerVaultAbi } from '../wagmi/generated.js';
+const ERC20_ABI = erc20Abi;
+const VAULT_ABI = steerVaultAbi;
+export async function simulateVaultWithdraw(params) {
+    const { client, vault, owner, withdrawPct, withdrawShares, debug = false, cliPool, viemChain } = params;
+    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);
+    let poolAddr;
+    try {
+        poolAddr = await client.readContract({ address: vaultAddr, abi: VAULT_ABI, 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: VAULT_ABI, functionName: 'decimals' }));
+    }
+    catch { }
+    const t0Addr = await client.readContract({ address: vaultAddr, abi: VAULT_ABI, functionName: 'token0' });
+    const t1Addr = await client.readContract({ address: vaultAddr, abi: VAULT_ABI, functionName: 'token1' });
+    const [t0Dec, t1Dec] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'decimals' }),
+        client.readContract({ address: t1Addr, abi: ERC20_ABI, functionName: 'decimals' }),
+    ]);
+    let [t0Sym, t1Sym] = ['T0', 'T1'];
+    try {
+        t0Sym = await client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'symbol' });
+    }
+    catch { }
+    try {
+        t1Sym = await client.readContract({ address: t1Addr, abi: ERC20_ABI, 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}`;
+    let shares = withdrawShares != null ? BigInt(withdrawShares) : undefined;
+    if (shares == null && withdrawPct != null) {
+        const bal = await client.readContract({ address: vaultAddr, abi: ERC20_ABI, 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: ERC20_ABI, functionName: 'balanceOf', args: [ownerAddr] });
+    const totalShares = await client.readContract({ address: vaultAddr, abi: ERC20_ABI, 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;
+    }
+    try {
+        await client.setBalance({ address: ownerAddr, value: parseEther('0.05') });
+    }
+    catch { }
+    try {
+        await client.impersonateAccount({ address: ownerAddr });
+    }
+    catch { }
+    const [o0b, o1b, v0b, v1b] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t1Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [vaultAddr] }),
+        client.readContract({ address: t1Addr, abi: ERC20_ABI, 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)}`);
+    }
+    const data = encodeFunctionData({ abi: VAULT_ABI, functionName: 'withdraw', args: [shares, 0n, 0n, ownerAddr] });
+    try {
+        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 });
+    const [o0a, o1a, v0a, v1a] = await Promise.all([
+        client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t1Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [ownerAddr] }),
+        client.readContract({ address: t0Addr, abi: ERC20_ABI, functionName: 'balanceOf', args: [vaultAddr] }),
+        client.readContract({ address: t1Addr, abi: ERC20_ABI, 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;
+}
+export 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;
+}
+export 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;
+}

package/dist/api.d.ts

@@ -0,0 +1,72 @@
+import { computeMarketDepthBands } from './core/depth.js';
+export type AnalyzeSource = 'tevm' | 'subgraph' | 'auto';
+export type AnalyzeOptions = {
+    poolAddress: string;
+    source?: AnalyzeSource;
+    rpcUrl?: string;
+    subgraphUrl?: string;
+    percentBuckets?: number[];
+    usdSizes?: number[];
+    token0USD?: number;
+    token1USD?: number;
+    assumeStable?: 0 | 1;
+    prices?: 'reserve' | 'dexscreener' | 'llama' | 'coingecko' | 'auto';
+    reserveLimit?: number;
+    debug?: boolean;
+    withdraw?: {
+        vault: string;
+        owner: string;
+        withdrawPct?: number;
+        withdrawShares?: string | number | bigint;
+    };
+};
+export type AnalyzeResult = {
+    before: SingleAnalysis;
+    after?: SingleAnalysis;
+};
+export type SingleAnalysis = {
+    pool: string;
+    tokens: {
+        token0: {
+            id?: string;
+            symbol?: string;
+        };
+        token1: {
+            id?: string;
+            symbol?: string;
+        };
+    };
+    ethPriceUSD?: number;
+    tick: number;
+    sqrtPriceX96: string;
+    liquidity: string;
+    feePips: number;
+    range: {
+        start: number;
+        end: number;
+    };
+    percentBuckets: number[];
+    prices: {
+        token0?: {
+            address?: string;
+            symbol?: string;
+            usd?: number;
+            source?: string;
+        };
+        token1?: {
+            address?: string;
+            symbol?: string;
+            usd?: number;
+            source?: string;
+        };
+    };
+    buyCumToken1: string[];
+    sellCumToken0: string[];
+    metrics: ReturnType<typeof computeMarketDepthBands>;
+    priceImpacts?: {
+        usdSizes: number[];
+        buyPct: number[];
+        sellPct: number[];
+    };
+};
+export declare function analyzePool(opts: AnalyzeOptions): Promise<AnalyzeResult>;

package/dist/api.js

@@ -0,0 +1,180 @@
+import { createMemoryClient, http as tevmHttp } from 'tevm';
+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 { resolveTevmCommon, simulateVaultWithdraw } from './adapters/withdraw.js';
+export async function analyzePool(opts) {
+    const { poolAddress, source = 'auto', rpcUrl, subgraphUrl, percentBuckets = [1, 2, 5, 10], usdSizes = [], token0USD: token0Override, token1USD: token1Override, assumeStable, prices = 'auto', reserveLimit = 100, debug = false, withdraw, } = opts;
+    // Decide source
+    let used;
+    let client = null;
+    if (source === 'tevm' || (source === 'auto' && rpcUrl)) {
+        if (!rpcUrl)
+            throw new Error('analyzePool: rpcUrl required for tevm source');
+        const common = await resolveTevmCommon(rpcUrl);
+        client = createMemoryClient({ fork: { transport: tevmHttp(rpcUrl), blockTag: 'latest' }, loggingLevel: 'error', ...(common ? { common } : {}) });
+        if (client.tevmReady)
+            await client.tevmReady();
+        used = 'tevm';
+    }
+    else {
+        used = 'subgraph';
+    }
+    // Snapshot
+    const snap = used === 'tevm'
+        ? await fetchPoolSnapshotViem({ poolAddress, rpcUrl: rpcUrl, percentBuckets, client })
+        : await fetchFromSubgraph({ poolAddress, percentBuckets, subgraphUrl });
+    const before = await computeSnapshotMetrics({
+        poolAddress,
+        args: { token0USD: token0Override, token1USD: token1Override, assumeStable, usdSizes, prices, reserveLimit, debug, rpcUrl },
+        snap,
+        percentBuckets,
+    });
+    // Optional withdraw simulation on TEVM
+    let after;
+    if (used === 'tevm' && withdraw?.vault && withdraw?.owner && (Number.isFinite(withdraw.withdrawPct) || withdraw.withdrawShares != null)) {
+        await simulateVaultWithdraw({ client, vault: withdraw.vault, owner: withdraw.owner, withdrawPct: withdraw.withdrawPct, withdrawShares: withdraw.withdrawShares, debug });
+        const snap2 = await fetchPoolSnapshotViem({ poolAddress, client, percentBuckets });
+        after = await computeSnapshotMetrics({ poolAddress, args: { token0USD: token0Override, token1USD: token1Override, assumeStable, usdSizes, prices, reserveLimit, debug, rpcUrl }, snap: snap2, percentBuckets });
+    }
+    return { before, after };
+}
+async function computeSnapshotMetrics({ poolAddress, args, snap, percentBuckets }) {
+    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;
+            if (args.rpcUrl) {
+                try {
+                    const clientCID = createMemoryClient({ fork: { transport: tevmHttp(args.rpcUrl), blockTag: 'latest' }, loggingLevel: 'error' });
+                    if (clientCID.tevmReady)
+                        await clientCID.tevmReady();
+                    chainIdForPrices = await clientCID.getChainId();
+                }
+                catch { }
+            }
+            if (args.debug)
+                console.error(`[api] price fetch: addrs=${addrs.join(',')} source=${args.prices} rpc=${args.rpcUrl ? 'yes' : 'no'} chainId=${chainIdForPrices ?? 'n/a'}`);
+            const { byAddress } = await fetchTokenUSDPrices({ addresses: addrs, source: args.prices, chainId: chainIdForPrices, rpcUrl: args.rpcUrl, 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 metrics = 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 || []);
+    const 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;
+    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 {
+        pool: snap.meta?.poolId ?? poolAddress,
+        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 ?? { start: snap.tick, end: snap.tick },
+        percentBuckets,
+        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: metrics.buyCumToken1.map((x) => String(x)),
+        sellCumToken0: metrics.sellCumToken0.map((x) => String(x)),
+        metrics,
+        priceImpacts: priceImpacts ? { usdSizes, buyPct: priceImpacts.buyPct, sellPct: priceImpacts.sellPct } : undefined,
+    };
+}

package/dist/cli/liquidity-depth.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};