@clonegod/ttd-base-common 1.0.26 → 1.1.2

package/dist/quote/depth/clmm_depth_calculator.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateClmmDepth = calculateClmmDepth;
+exports.priceFromSqrtX96 = priceFromSqrtX96;
+exports.getSqrtRatioAtTick = getSqrtRatioAtTick;
+exports.computeTargetSqrtPrice = computeTargetSqrtPrice;
+exports.bigIntSqrt = bigIntSqrt;
+const Q96 = 1n << 96n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+function getSqrtRatioAtTick(tick) {
+    const absTick = Math.abs(tick);
+    if (absTick > 887272)
+        throw new Error(`Tick out of range: ${tick}`);
+    let ratio = (absTick & 0x1) !== 0
+        ? 0xfffcb933bd6fad37aa2d162d1a594001n
+        : 0x100000000000000000000000000000000n;
+    if (absTick & 0x2)
+        ratio = (ratio * 0xfff97272373d413259a46990580e213an) >> 128n;
+    if (absTick & 0x4)
+        ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn) >> 128n;
+    if (absTick & 0x8)
+        ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n) >> 128n;
+    if (absTick & 0x10)
+        ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n) >> 128n;
+    if (absTick & 0x20)
+        ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n) >> 128n;
+    if (absTick & 0x40)
+        ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n) >> 128n;
+    if (absTick & 0x80)
+        ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n) >> 128n;
+    if (absTick & 0x100)
+        ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n) >> 128n;
+    if (absTick & 0x200)
+        ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n) >> 128n;
+    if (absTick & 0x400)
+        ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n) >> 128n;
+    if (absTick & 0x800)
+        ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n) >> 128n;
+    if (absTick & 0x1000)
+        ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n) >> 128n;
+    if (absTick & 0x2000)
+        ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n) >> 128n;
+    if (absTick & 0x4000)
+        ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n) >> 128n;
+    if (absTick & 0x8000)
+        ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n) >> 128n;
+    if (absTick & 0x10000)
+        ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n) >> 128n;
+    if (absTick & 0x20000)
+        ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n) >> 128n;
+    if (absTick & 0x40000)
+        ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n) >> 128n;
+    if (absTick & 0x80000)
+        ratio = (ratio * 0x48a170391f7dc42444e8fa2n) >> 128n;
+    if (tick > 0)
+        ratio = MAX_UINT256 / ratio;
+    return (ratio >> 32n) + (ratio % (1n << 32n) === 0n ? 0n : 1n);
+}
+function calculateClmmDepth(input) {
+    const { poolAddress, tickCache, currentTick, tickSpacing, zeroForOne, targetBps, inputDecimals, outputDecimals, } = input;
+    const currentSqrtPriceX96 = BigInt(input.sqrtPriceX96);
+    let liquidity = BigInt(input.liquidity);
+    if (liquidity === 0n) {
+        return { amountInWei: 0n, amountIn: 0, amountOutWei: 0n, amountOut: 0, currentTick, targetTick: currentTick, targetSqrtPriceX96: currentSqrtPriceX96 };
+    }
+    const targetSqrtPriceX96 = computeTargetSqrtPrice(currentSqrtPriceX96, targetBps, zeroForOne);
+    const allTicks = tickCache.getCachedTickIndices(poolAddress);
+    const ticksToTraverse = getTicksBetween(allTicks, currentTick, targetSqrtPriceX96, zeroForOne, tickSpacing);
+    let totalInput = 0n;
+    let totalOutput = 0n;
+    let sqrtPriceCursor = currentSqrtPriceX96;
+    for (const tick of ticksToTraverse) {
+        const sqrtPriceAtTick = getSqrtRatioAtTick(tick);
+        if (zeroForOne && sqrtPriceAtTick <= targetSqrtPriceX96)
+            break;
+        if (!zeroForOne && sqrtPriceAtTick >= targetSqrtPriceX96)
+            break;
+        if (liquidity > 0n) {
+            totalInput += calcInputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+            totalOutput += calcOutputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+        }
+        let liquidityNet = tickCache.getTickLiquidityNet(poolAddress, tick) || 0n;
+        if (zeroForOne)
+            liquidityNet = -liquidityNet;
+        liquidity = liquidity + liquidityNet;
+        if (liquidity < 0n)
+            liquidity = 0n;
+        sqrtPriceCursor = sqrtPriceAtTick;
+    }
+    if (liquidity > 0n && sqrtPriceCursor !== targetSqrtPriceX96) {
+        totalInput += calcInputForRange(sqrtPriceCursor, targetSqrtPriceX96, liquidity, zeroForOne);
+        totalOutput += calcOutputForRange(sqrtPriceCursor, targetSqrtPriceX96, liquidity, zeroForOne);
+    }
+    const amountIn = Number(totalInput) / Math.pow(10, inputDecimals);
+    const amountOut = Number(totalOutput) / Math.pow(10, outputDecimals);
+    const sqrtPriceFloat = Number(targetSqrtPriceX96) / Number(Q96);
+    const targetTick = Math.floor(Math.log(sqrtPriceFloat * sqrtPriceFloat) / Math.log(1.0001));
+    return { amountInWei: totalInput, amountIn, amountOutWei: totalOutput, amountOut, currentTick, targetTick, targetSqrtPriceX96 };
+}
+function priceFromSqrtX96(sqrtPriceX96, baseDecimals, quoteDecimals, baseIsToken0) {
+    const sp = Number(sqrtPriceX96) / Number(Q96);
+    const priceToken1PerToken0 = sp * sp;
+    if (baseIsToken0) {
+        return priceToken1PerToken0 * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+    else {
+        return (1 / priceToken1PerToken0) * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+}
+function computeTargetSqrtPrice(currentSqrtPriceX96, bps, zeroForOne) {
+    const PRECISION = 10n ** 18n;
+    const bpsBigInt = BigInt(bps);
+    let factor;
+    if (zeroForOne) {
+        factor = 10000n - bpsBigInt;
+    }
+    else {
+        factor = 10000n + bpsBigInt;
+    }
+    const sqrtFactor = bigIntSqrt(factor * PRECISION);
+    const sqrtBase = bigIntSqrt(10000n * PRECISION);
+    return currentSqrtPriceX96 * sqrtFactor / sqrtBase;
+}
+function bigIntSqrt(n) {
+    if (n < 0n)
+        throw new Error('sqrt of negative');
+    if (n === 0n)
+        return 0n;
+    if (n <= 3n)
+        return 1n;
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+        x = y;
+        y = (x + n / x) / 2n;
+    }
+    return x;
+}
+function getTicksBetween(allTicks, currentTick, targetSqrtPriceX96, zeroForOne, tickSpacing) {
+    if (zeroForOne) {
+        return allTicks
+            .filter(t => t <= currentTick)
+            .sort((a, b) => b - a);
+    }
+    else {
+        return allTicks
+            .filter(t => t > currentTick)
+            .sort((a, b) => a - b);
+    }
+}
+function calcInputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const sqrtPriceLower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const sqrtPriceUpper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff * Q96 / (sqrtPriceLower * sqrtPriceUpper);
+    }
+    else {
+        return liquidity * diff / Q96;
+    }
+}
+function calcOutputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const sqrtPriceLower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const sqrtPriceUpper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff / Q96;
+    }
+    else {
+        return liquidity * diff * Q96 / (sqrtPriceLower * sqrtPriceUpper);
+    }
+}

package/dist/quote/depth/index.d.ts

@@ -0,0 +1,51 @@
+import { QuoteDepthOutput } from '@clonegod/ttd-core';
+import { ClmmTickCache } from '../tick/clmm_tick_cache';
+export { calculateClmmDepth, getSqrtRatioAtTick, computeTargetSqrtPrice, bigIntSqrt, priceFromSqrtX96 } from './clmm_depth_calculator';
+export type { ClmmDepthInput, DepthResult } from './clmm_depth_calculator';
+export { calculateAmmDepth } from './amm_depth_calculator';
+export type { AmmDepthInput, AmmDepthResult } from './amm_depth_calculator';
+export { buildTickLiquiditySnapshot } from './tick_liquidity_snapshot';
+export type { TickLiquiditySnapshot, TickLiquiditySnapshotInput, TickDataPoint } from './tick_liquidity_snapshot';
+import { TickLiquiditySnapshot } from './tick_liquidity_snapshot';
+export declare function logFeeChainConfigOnce(poolName: string, poolAddress: string, configFeeBps: number, chainFeeBps: number, dexId?: string, pair?: string): void;
+export declare function clearFeeMatchLogged(poolAddress: string): void;
+export interface BuildClmmDepthInput {
+    poolInfo: {
+        pool_name: string;
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+    poolAddress: string;
+    tickCache: ClmmTickCache;
+    poolState: {
+        tick: number;
+        sqrtPriceX96: string;
+        liquidity: string;
+        tickSpacing: number;
+        token0: string;
+    };
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    feeRateBps: number;
+}
+export interface ClmmDepthResult {
+    depth: QuoteDepthOutput;
+    tickLiquidity?: TickLiquiditySnapshot;
+}
+export declare function buildClmmDepth(input: BuildClmmDepthInput): ClmmDepthResult | undefined;
+export interface BuildAmmDepthInput {
+    poolInfo: {
+        pool_name: string;
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+    reserve0: string;
+    reserve1: string;
+    token0Address: string;
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    feeRateBps: number;
+}
+export declare function buildAmmDepth(input: BuildAmmDepthInput): QuoteDepthOutput | undefined;

package/dist/quote/depth/index.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTickLiquiditySnapshot = exports.calculateAmmDepth = exports.priceFromSqrtX96 = exports.bigIntSqrt = exports.computeTargetSqrtPrice = exports.getSqrtRatioAtTick = exports.calculateClmmDepth = void 0;
+exports.logFeeChainConfigOnce = logFeeChainConfigOnce;
+exports.clearFeeMatchLogged = clearFeeMatchLogged;
+exports.buildClmmDepth = buildClmmDepth;
+exports.buildAmmDepth = buildAmmDepth;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const ttd_core_2 = require("@clonegod/ttd-core");
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+const amm_depth_calculator_1 = require("./amm_depth_calculator");
+const trade_direction_1 = require("../../utils/trade_direction");
+var clmm_depth_calculator_2 = require("./clmm_depth_calculator");
+Object.defineProperty(exports, "calculateClmmDepth", { enumerable: true, get: function () { return clmm_depth_calculator_2.calculateClmmDepth; } });
+Object.defineProperty(exports, "getSqrtRatioAtTick", { enumerable: true, get: function () { return clmm_depth_calculator_2.getSqrtRatioAtTick; } });
+Object.defineProperty(exports, "computeTargetSqrtPrice", { enumerable: true, get: function () { return clmm_depth_calculator_2.computeTargetSqrtPrice; } });
+Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function () { return clmm_depth_calculator_2.bigIntSqrt; } });
+Object.defineProperty(exports, "priceFromSqrtX96", { enumerable: true, get: function () { return clmm_depth_calculator_2.priceFromSqrtX96; } });
+var amm_depth_calculator_2 = require("./amm_depth_calculator");
+Object.defineProperty(exports, "calculateAmmDepth", { enumerable: true, get: function () { return amm_depth_calculator_2.calculateAmmDepth; } });
+var tick_liquidity_snapshot_1 = require("./tick_liquidity_snapshot");
+Object.defineProperty(exports, "buildTickLiquiditySnapshot", { enumerable: true, get: function () { return tick_liquidity_snapshot_1.buildTickLiquiditySnapshot; } });
+const tick_liquidity_snapshot_2 = require("./tick_liquidity_snapshot");
+const clmm_tick_cache_1 = require("../tick/clmm_tick_cache");
+let _depthPctLogged = false;
+function logDepthLevelsOnce() {
+    if (_depthPctLogged)
+        return;
+    _depthPctLogged = true;
+    const pcts = (0, ttd_core_2.getDepthPricePctLevels)();
+    (0, ttd_core_1.log_info)(`[Depth] pctLevels=${JSON.stringify(pcts)}, default=${ttd_core_2.DEFAULT_TIER_PCT}`);
+}
+const _feeMatchLoggedPools = new Set();
+function logFeeChainConfigOnce(poolName, poolAddress, configFeeBps, chainFeeBps, dexId, pair) {
+    if (_feeMatchLoggedPools.has(poolAddress))
+        return;
+    _feeMatchLoggedPools.add(poolAddress);
+    const diff = Math.abs(configFeeBps - chainFeeBps);
+    const drifted = diff >= 0.01;
+    if (drifted) {
+        (0, ttd_core_1.log_warn)(`[Fee] ${poolName} 配置漂移: config=${configFeeBps}bps ≠ chain=${chainFeeBps}bps (差 ${diff.toFixed(2)}bps) — 已用链上值，请运维检查池子配置`);
+    }
+    else {
+        (0, ttd_core_1.log_info)(`[Fee] ${poolName} config=${configFeeBps}bps == chain=${chainFeeBps}bps ✓`);
+    }
+    const addrLower = poolAddress.toLowerCase();
+    ttd_core_2.ALERT_TYPES.QUOTE_FEE_CHAIN_DRIFT.reportIfChanged(addrLower, drifted, () => ({
+        identity: addrLower,
+        scope: { dex_id: dexId, pool_address: addrLower, pair },
+        title: `${poolName} fee 漂移 cfg=${configFeeBps}bps chain=${chainFeeBps}bps`,
+        detail: {
+            pool_name: poolName,
+            config_fee_bps: configFeeBps,
+            chain_fee_bps: chainFeeBps,
+            diff_bps: diff,
+        },
+    }));
+}
+function clearFeeMatchLogged(poolAddress) {
+    _feeMatchLoggedPools.delete(poolAddress);
+}
+function grossUpFee(amountInNet, feeRateBps) {
+    if (feeRateBps <= 0 || amountInNet <= 0) {
+        return { amountInGross: amountInNet, feeAmount: 0 };
+    }
+    const feeRatio = feeRateBps / 10000;
+    const amountInGross = amountInNet / (1 - feeRatio);
+    const feeAmount = amountInGross - amountInNet;
+    return { amountInGross, feeAmount };
+}
+const _tickLiquidityLastBuild = new Map();
+function assembleEntry(tiers) {
+    const defaultTier = tiers.find(t => t.pct === ttd_core_2.DEFAULT_TIER_PCT) ?? tiers[0];
+    return {
+        price: defaultTier.price,
+        amount: defaultTier.amount,
+        amount_in: defaultTier.amount_in,
+        amount_in_usd: defaultTier.amount_in_usd,
+        fee: defaultTier.fee,
+        fee_usd: defaultTier.fee_usd,
+        tick_move: defaultTier.tick_move,
+        tiers,
+    };
+}
+function buildClmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, ttd_core_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, poolAddress, tickCache, poolState, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (BigInt(poolState.liquidity) === 0n)
+        return undefined;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+    try {
+        const askDirection = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const bidDirection = (0, trade_direction_1.resolveTradeDirection)(poolInfo, false);
+        const askZeroForOne = askDirection.inputToken.address.toLowerCase() === poolState.token0.toLowerCase();
+        const bidZeroForOne = bidDirection.inputToken.address.toLowerCase() === poolState.token0.toLowerCase();
+        const baseToken = askDirection.baseToken;
+        const quoteToken = askDirection.quoteToken;
+        const baseIsToken0 = baseToken.address.toLowerCase() === poolState.token0.toLowerCase();
+        const midPrice = (0, clmm_depth_calculator_1.priceFromSqrtX96)(BigInt(poolState.sqrtPriceX96), baseToken.decimals, quoteToken.decimals, baseIsToken0);
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                poolAddress, tickCache,
+                currentTick: poolState.tick, sqrtPriceX96: poolState.sqrtPriceX96,
+                liquidity: poolState.liquidity, tickSpacing: poolState.tickSpacing,
+                zeroForOne: askZeroForOne, targetBps: bps,
+                inputDecimals: quoteToken.decimals, outputDecimals: baseToken.decimals,
+            });
+            const bidResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                poolAddress, tickCache,
+                currentTick: poolState.tick, sqrtPriceX96: poolState.sqrtPriceX96,
+                liquidity: poolState.liquidity, tickSpacing: poolState.tickSpacing,
+                zeroForOne: bidZeroForOne, targetBps: bps,
+                inputDecimals: baseToken.decimals, outputDecimals: quoteToken.decimals,
+            });
+            const askTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX96)(askResult.targetSqrtPriceX96, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const bidTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX96)(bidResult.targetSqrtPriceX96, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            const askTickMove = askResult.targetTick < askResult.currentTick
+                ? `${askResult.targetTick} <- ${askResult.currentTick}`
+                : `${askResult.currentTick} -> ${askResult.targetTick}`;
+            const bidTickMove = bidResult.targetTick > bidResult.currentTick
+                ? `${bidResult.currentTick} -> ${bidResult.targetTick}`
+                : `${bidResult.targetTick} <- ${bidResult.currentTick}`;
+            askTiers.push({
+                pct,
+                price: askTargetPrice,
+                amount: askResult.amountOut,
+                amount_in: askGross.amountInGross,
+                amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount,
+                fee_usd: askGross.feeAmount * quotePriceUsd,
+                tick_move: askTickMove,
+            });
+            bidTiers.push({
+                pct,
+                price: bidTargetPrice,
+                amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross,
+                amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount,
+                fee_usd: bidGross.feeAmount * basePriceUsd,
+                tick_move: bidTickMove,
+            });
+        }
+        const depth = {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+        let tickLiquidity;
+        const now = Date.now();
+        const lastBuild = _tickLiquidityLastBuild.get(poolAddress) || 0;
+        if (now - lastBuild < clmm_tick_cache_1.TICK_REFRESH_INTERVAL_MS) {
+            return { depth, tickLiquidity: undefined };
+        }
+        _tickLiquidityLastBuild.set(poolAddress, now);
+        try {
+            const tokenAIsToken0 = poolInfo.tokenA?.address?.toLowerCase() === poolState.token0.toLowerCase();
+            const token0Info = tokenAIsToken0 ? poolInfo.tokenA : poolInfo.tokenB;
+            const token1Info = tokenAIsToken0 ? poolInfo.tokenB : poolInfo.tokenA;
+            tickLiquidity = (0, tick_liquidity_snapshot_2.buildTickLiquiditySnapshot)({
+                poolAddress,
+                pair: '',
+                protocolId: '',
+                tickCache,
+                currentTick: poolState.tick,
+                sqrtPriceX96: poolState.sqrtPriceX96,
+                liquidity: poolState.liquidity,
+                tickSpacing: poolState.tickSpacing,
+                token0: { address: poolState.token0, symbol: token0Info?.symbol || '', decimals: token0Info?.decimals || 18 },
+                token1: { address: token1Info?.address || '', symbol: token1Info?.symbol || '', decimals: token1Info?.decimals || 18 },
+                baseIsToken0,
+                token0PriceUsd: baseIsToken0 ? basePriceUsd : quotePriceUsd,
+                token1PriceUsd: baseIsToken0 ? quotePriceUsd : basePriceUsd,
+            });
+        }
+        catch (e) {
+            (0, ttd_core_1.log_debug)(`[TickLiquidity] ${poolInfo.pool_name} failed: ${e.message}`, '');
+        }
+        return { depth, tickLiquidity };
+    }
+    catch (error) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM depth failed: ${error.message}`, '');
+        return undefined;
+    }
+}
+function buildAmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, ttd_core_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, reserve0, reserve1, token0Address, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} AMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+    try {
+        const askDirection = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = askDirection.baseToken;
+        const quoteToken = askDirection.quoteToken;
+        const baseIsToken0 = baseToken.address.toLowerCase() === token0Address.toLowerCase();
+        const baseDec = baseIsToken0 ? baseToken.decimals : quoteToken.decimals;
+        const quoteDec = baseIsToken0 ? quoteToken.decimals : baseToken.decimals;
+        const baseReserveUi = Number(BigInt(baseIsToken0 ? reserve0 : reserve1)) / Math.pow(10, baseToken.decimals);
+        const quoteReserveUi = Number(BigInt(baseIsToken0 ? reserve1 : reserve0)) / Math.pow(10, quoteToken.decimals);
+        const midPrice = quoteReserveUi / baseReserveUi;
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: true, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const bidResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: false, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            askTiers.push({
+                pct,
+                price: askResult.targetPrice,
+                amount: askResult.amountOut,
+                amount_in: askGross.amountInGross,
+                amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount,
+                fee_usd: askGross.feeAmount * quotePriceUsd,
+            });
+            bidTiers.push({
+                pct,
+                price: bidResult.targetPrice,
+                amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross,
+                amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount,
+                fee_usd: bidGross.feeAmount * basePriceUsd,
+            });
+        }
+        return {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+    }
+    catch (error) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} AMM depth failed: ${error.message}`, '');
+        return undefined;
+    }
+}

package/dist/quote/depth/tick_liquidity_snapshot.d.ts

@@ -0,0 +1,58 @@
+import { ClmmTickCache } from '../tick/clmm_tick_cache';
+export interface TickLiquiditySnapshotInput {
+    poolAddress: string;
+    pair: string;
+    protocolId: string;
+    tickCache: ClmmTickCache;
+    currentTick: number;
+    sqrtPriceX96: string;
+    liquidity: string;
+    tickSpacing: number;
+    token0: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    token1: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    baseIsToken0: boolean;
+    token0PriceUsd: number;
+    token1PriceUsd: number;
+    rangeBps?: number;
+}
+export interface TickDataPoint {
+    tick: number;
+    price0: number;
+    price1: number;
+    liquidity: string;
+    amount0: number;
+    amount1: number;
+    tvlUsd: number;
+    buyable: number;
+    sellable: number;
+}
+export interface TickLiquiditySnapshot {
+    poolAddress: string;
+    pair: string;
+    protocolId: string;
+    currentTick: number;
+    tickSpacing: number;
+    currentPrice: number;
+    token0: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    token1: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    ticks: TickDataPoint[];
+    totalTvlUsd: number;
+    timestamp: number;
+}
+export declare function buildTickLiquiditySnapshot(input: TickLiquiditySnapshotInput): TickLiquiditySnapshot | undefined;