@clonegod/ttd-bsc-common 3.1.65 → 3.1.67

package/dist/appconfig/bsc_env_args.d.ts

@@ -32,6 +32,7 @@ export declare class BscEnvArgs extends EnvArgs {
     redis_url: string;
     skip_pool_list: string;
     price_feed_skip_dup: boolean;
+    price_feed_client_id: string;
     trade_analyze_port: number;
     log_max_size_mb: number;
     log_check_interval_min: number;

package/dist/appconfig/bsc_env_args.js

@@ -36,6 +36,7 @@ const constants_1 = require("../common/constants");
     redis_url: { env: 'REDIS_URL', type: 'string', default: 'redis://127.0.0.1:6379', desc: 'Redis 连接 URL' },
     skip_pool_list: { env: 'SKIP_POOL_LIST', type: 'string', default: '', desc: '跳过的池子名称列表(逗号分隔)' },
     price_feed_skip_dup: { env: 'PRICE_FEED_SKIP_DUP', type: 'boolean', default: false, desc: 'PriceFeed 去重过滤' },
+    price_feed_client_id: { env: 'PRICE_FEED_CLIENT_ID', type: 'string', default: 'BSC_DC', desc: 'PriceFeed 订阅消息里的 client 标识（如 yyNode 区分客户端）' },
     trade_analyze_port: { env: 'TRADE_ANALYZE_PORT', type: 'number', default: 8004, desc: '上报 analyze 的 HTTP 端口' },
     log_max_size_mb: { env: 'LOG_MAX_SIZE_MB', type: 'number', default: 20, desc: '日志文件大小上限(MB)' },
     log_check_interval_min: { env: 'LOG_CHECK_INTERVAL_MIN', type: 'number', default: 10, desc: '日志检查间隔(分钟)' },

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

@@ -11,5 +11,9 @@ export interface AmmDepthResult {
     amountOutWei: bigint;
     amountOut: number;
     outputDecimals: number;
+    amountInWei: bigint;
+    amountIn: number;
+    inputDecimals: number;
+    targetPrice: number;
 }
 export declare function calculateAmmDepth(input: AmmDepthInput): AmmDepthResult;

package/dist/quote/depth/amm_depth_calculator.js

@@ -7,32 +7,49 @@ function calculateAmmDepth(input) {
     const R0 = BigInt(input.reserve0);
     const R1 = BigInt(input.reserve1);
     if (R0 === 0n || R1 === 0n) {
-        return { amountOutWei: 0n, amountOut: 0, outputDecimals: 0 };
+        return { amountOutWei: 0n, amountOut: 0, outputDecimals: 0, amountInWei: 0n, amountIn: 0, inputDecimals: 0, targetPrice: 0 };
     }
     const k = R0 * R1;
     const bps = BigInt(targetBps);
     const PRECISION = 10n ** 18n;
     let amountOutWei;
+    let amountInWei;
     let outputDecimals;
+    let inputDecimals;
     if (isBuy) {
         const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
         outputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
-        const numerator = k * 10000n * PRECISION;
-        const denominator = (10000n + bps) * quoteReserve;
+        inputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
         const baseReserveNew = baseReserve * (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)((10000n + bps) * PRECISION);
+        const quoteReserveNew = quoteReserve * (0, clmm_depth_calculator_1.bigIntSqrt)((10000n + bps) * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION);
         amountOutWei = baseReserve - baseReserveNew;
+        amountInWei = quoteReserveNew - quoteReserve;
     }
     else {
         const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
         outputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
+        inputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
         if (bps >= 10000n) {
             amountOutWei = quoteReserve;
+            amountInWei = baseReserve;
         }
         else {
             const quoteReserveNew = quoteReserve * (0, clmm_depth_calculator_1.bigIntSqrt)((10000n - bps) * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION);
+            const baseReserveNew = baseReserve * (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)((10000n - bps) * PRECISION);
             amountOutWei = quoteReserve - quoteReserveNew;
+            amountInWei = baseReserveNew - baseReserve;
         }
     }
     const amountOut = Number(amountOutWei) / Math.pow(10, outputDecimals);
-    return { amountOutWei, amountOut, outputDecimals };
+    const amountIn = Number(amountInWei) / Math.pow(10, inputDecimals);
+    const baseDec = baseIsToken0 ? token0Decimals : token1Decimals;
+    const quoteDec = baseIsToken0 ? token1Decimals : token0Decimals;
+    const baseReserveUi = Number(baseIsToken0 ? R0 : R1) / Math.pow(10, baseDec);
+    const quoteReserveUi = Number(baseIsToken0 ? R1 : R0) / Math.pow(10, quoteDec);
+    const midPrice = quoteReserveUi / baseReserveUi;
+    const bpsNum = Number(targetBps);
+    const targetPrice = isBuy
+        ? midPrice * (10000 + bpsNum) / 10000
+        : midPrice * (10000 - bpsNum) / 10000;
+    return { amountOutWei, amountOut, outputDecimals, amountInWei, amountIn, inputDecimals, targetPrice };
 }

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

@@ -19,8 +19,10 @@ export interface DepthResult {
     amountOut: number;
     currentTick: number;
     targetTick: number;
+    targetSqrtPriceX96: bigint;
 }
 export declare function calculateClmmDepth(input: ClmmDepthInput): DepthResult;
+export declare function priceFromSqrtX96(sqrtPriceX96: bigint, baseDecimals: number, quoteDecimals: number, baseIsToken0: boolean): number;
 declare function computeTargetSqrtPrice(currentSqrtPriceX96: bigint, bps: number, zeroForOne: boolean): bigint;
 declare function bigIntSqrt(n: bigint): bigint;
 export { getSqrtRatioAtTick, computeTargetSqrtPrice, bigIntSqrt };

package/dist/quote/depth/clmm_depth_calculator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateClmmDepth = calculateClmmDepth;
+exports.priceFromSqrtX96 = priceFromSqrtX96;
 exports.getSqrtRatioAtTick = getSqrtRatioAtTick;
 exports.computeTargetSqrtPrice = computeTargetSqrtPrice;
 exports.bigIntSqrt = bigIntSqrt;
@@ -60,7 +61,7 @@ function calculateClmmDepth(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 };
+        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);
@@ -94,7 +95,17 @@ function calculateClmmDepth(input) {
     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 };
+    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;

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

@@ -1,14 +1,14 @@
+import { QuoteDepthOutput } from '@clonegod/ttd-core';
 import { ClmmTickCache } from '../tick/clmm_tick_cache';
-export { calculateClmmDepth, getSqrtRatioAtTick, computeTargetSqrtPrice, bigIntSqrt } from './clmm_depth_calculator';
+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';
-import { PoolDepthData } from '@clonegod/ttd-core';
-export type { PoolDepthData } from '@clonegod/ttd-core';
-export declare function getDepthBps(): number[];
+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;
@@ -27,9 +27,10 @@ export interface BuildClmmDepthInput {
     };
     basePriceUsd: number;
     quotePriceUsd: number;
+    feeRateBps: number;
 }
 export interface ClmmDepthResult {
-    depth: PoolDepthData;
+    depth: QuoteDepthOutput;
     tickLiquidity?: TickLiquiditySnapshot;
 }
 export declare function buildClmmDepth(input: BuildClmmDepthInput): ClmmDepthResult | undefined;
@@ -45,5 +46,6 @@ export interface BuildAmmDepthInput {
     token0Address: string;
     basePriceUsd: number;
     quotePriceUsd: number;
+    feeRateBps: number;
 }
-export declare function buildAmmDepth(input: BuildAmmDepthInput): PoolDepthData | undefined;
+export declare function buildAmmDepth(input: BuildAmmDepthInput): QuoteDepthOutput | undefined;

package/dist/quote/depth/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTickLiquiditySnapshot = exports.calculateAmmDepth = exports.bigIntSqrt = exports.computeTargetSqrtPrice = exports.getSqrtRatioAtTick = exports.calculateClmmDepth = void 0;
-exports.getDepthBps = getDepthBps;
+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");
@@ -13,39 +15,85 @@ Object.defineProperty(exports, "calculateClmmDepth", { enumerable: true, get: fu
 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 _depthBpsLogged = false;
-const DEFAULT_BPS = 20;
-function getDepthBps() {
-    const raw = process.env.DEPTH_BPS_LEVELS;
-    const levels = raw
-        ? raw.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n) && n > 0)
-        : [DEFAULT_BPS];
-    const cexBps = parseInt(process.env.DEPTH_CEX_BPS || String(DEFAULT_BPS));
-    if (!levels.includes(cexBps))
-        levels.push(cexBps);
-    if (!levels.includes(DEFAULT_BPS))
-        levels.push(DEFAULT_BPS);
-    levels.sort((a, b) => a - b);
-    if (!_depthBpsLogged) {
-        _depthBpsLogged = true;
-        (0, ttd_core_1.log_info)(`[Depth] bpsLevels=${JSON.stringify(levels)}, cexBps=${cexBps}`);
+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 ✓`);
     }
-    return levels;
+    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) {
-    const bpsLevels = getDepthBps();
-    if (bpsLevels.length === 0)
+    logDepthLevelsOnce();
+    const pctLevels = (0, ttd_core_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
         return undefined;
-    const { poolInfo, poolAddress, tickCache, poolState, basePriceUsd, quotePriceUsd } = input;
+    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);
@@ -53,8 +101,12 @@ function buildClmmDepth(input) {
         const bidZeroForOne = bidDirection.inputToken.address.toLowerCase() === poolState.token0.toLowerCase();
         const baseToken = askDirection.baseToken;
         const quoteToken = askDirection.quoteToken;
-        const depth = { ask: {}, bid: {} };
-        for (const bps of bpsLevels) {
+        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,
@@ -69,15 +121,43 @@ function buildClmmDepth(input) {
                 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}`;
-            depth.ask[bps] = { amount: askResult.amountOut, amountUsd: askResult.amountOut * basePriceUsd, amountIn: askResult.amountIn, amountInUsd: askResult.amountIn * quotePriceUsd, tickMove: askTickMove };
-            depth.bid[bps] = { amount: bidResult.amountOut, amountUsd: bidResult.amountOut * quotePriceUsd, amountIn: bidResult.amountIn, amountInUsd: bidResult.amountIn * basePriceUsd, tickMove: bidTickMove };
+            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;
@@ -86,7 +166,6 @@ function buildClmmDepth(input) {
         }
         _tickLiquidityLastBuild.set(poolAddress, now);
         try {
-            const baseIsToken0 = baseToken.address.toLowerCase() === poolState.token0.toLowerCase();
             const tokenAIsToken0 = poolInfo.tokenA?.address?.toLowerCase() === poolState.token0.toLowerCase();
             const token0Info = tokenAIsToken0 ? poolInfo.tokenA : poolInfo.tokenB;
             const token1Info = tokenAIsToken0 ? poolInfo.tokenB : poolInfo.tokenA;
@@ -117,17 +196,29 @@ function buildClmmDepth(input) {
     }
 }
 function buildAmmDepth(input) {
-    const bpsLevels = getDepthBps();
-    if (bpsLevels.length === 0)
+    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;
-    const { poolInfo, reserve0, reserve1, token0Address, basePriceUsd, quotePriceUsd } = input;
+    }
     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 depth = { ask: {}, bid: {} };
-        for (const bps of bpsLevels) {
+        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,
@@ -138,10 +229,33 @@ function buildAmmDepth(input) {
                 token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
                 token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
             });
-            depth.ask[bps] = { amount: askResult.amountOut, amountUsd: askResult.amountOut * basePriceUsd, amountIn: 0, amountInUsd: 0 };
-            depth.bid[bps] = { amount: bidResult.amountOut, amountUsd: bidResult.amountOut * quotePriceUsd, amountIn: 0, amountInUsd: 0 };
+            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 depth;
+        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}`, '');

package/dist/quote/hook_fee_monitor.d.ts

@@ -0,0 +1,10 @@
+export declare function reportHookFeeChangeIfChanged(opts: {
+    pool_address: string;
+    dex_id: string;
+    pool_name?: string;
+    block_number: number;
+    prevLpFee: number | undefined;
+    prevProtocolFee: number | undefined;
+    newLpFee: number;
+    newProtocolFee: number;
+}): void;

package/dist/quote/hook_fee_monitor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportHookFeeChangeIfChanged = reportHookFeeChangeIfChanged;
+const ttd_core_1 = require("@clonegod/ttd-core");
+function reportHookFeeChangeIfChanged(opts) {
+    const { pool_address, dex_id, pool_name, block_number, prevLpFee, prevProtocolFee, newLpFee, newProtocolFee } = opts;
+    if (prevLpFee == null)
+        return;
+    const prevTotal = prevLpFee + (prevProtocolFee ?? 0);
+    const newTotal = newLpFee + newProtocolFee;
+    if (prevTotal === newTotal)
+        return;
+    const addr = pool_address.toLowerCase();
+    const prevBps = (prevTotal / 100).toFixed(2);
+    const newBps = (newTotal / 100).toFixed(2);
+    ttd_core_1.ALERT_TYPES.QUOTE_HOOK_FEE_CHANGE.reportIfChanged(addr, true, () => ({
+        identity: addr,
+        scope: { dex_id, pool_address: addr },
+        title: `${pool_name || addr.slice(0, 10)} hook fee ${prevBps}bps → ${newBps}bps`,
+        detail: {
+            pool_name: pool_name || '',
+            block_number,
+            prev_lp_fee_ppm: prevLpFee,
+            prev_protocol_fee_ppm: prevProtocolFee ?? 0,
+            prev_total_ppm: prevTotal,
+            new_lp_fee_ppm: newLpFee,
+            new_protocol_fee_ppm: newProtocolFee,
+            new_total_ppm: newTotal,
+            delta_ppm: newTotal - prevTotal,
+        },
+    }));
+}

package/dist/quote/index.d.ts

@@ -6,3 +6,4 @@ export * from './verify';
 export * from './price_feed_handler';
 export * from './quote_amount';
 export * from './preload_token_prices';
+export * from './hook_fee_monitor';

package/dist/quote/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./verify"), exports);
 __exportStar(require("./price_feed_handler"), exports);
 __exportStar(require("./quote_amount"), exports);
 __exportStar(require("./preload_token_prices"), exports);
+__exportStar(require("./hook_fee_monitor"), exports);

package/dist/quote/pricing/pool_state_initializer.d.ts

@@ -1,4 +1,6 @@
 import { AmmPoolState, ClmmPoolState, InfinityPoolState } from "../../types/pool_state";
+declare function withInitRetry<T>(fn: () => Promise<T>, label: string): Promise<T>;
+export { withInitRetry };
 export declare class PoolStateInitializer {
     static initAmmPool(provider: any, poolAddress: string, dexId: string, ethersLib: any): Promise<AmmPoolState>;
     static initClmmPool(provider: any, poolAddress: string, ethersLib: any, poolAbi?: any[]): Promise<ClmmPoolState>;

package/dist/quote/pricing/pool_state_initializer.js

@@ -1,7 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolStateInitializer = void 0;
+exports.withInitRetry = withInitRetry;
 const ttd_core_1 = require("@clonegod/ttd-core");
+async function withInitRetry(fn, label) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        (0, ttd_core_1.log_warn)(`[PoolStateInitializer] ${label} attempt 1 failed: ${err?.message || err}, retrying once...`);
+        try {
+            return await fn();
+        }
+        catch (err2) {
+            (0, ttd_core_1.log_error)(`[PoolStateInitializer] ${label} retry also failed`, err2 instanceof Error ? err2 : new Error(String(err2)));
+            const addrMatch = label.match(/0x[0-9a-fA-F]+/);
+            const identity = (addrMatch?.[0] || label).toLowerCase();
+            ttd_core_1.ALERT_TYPES.QUOTE_POOL_INIT_FAILED.report({
+                severity: 'critical',
+                identity,
+                scope: { pool_address: addrMatch ? identity : undefined },
+                title: `Pool init failed: ${label} — ${err2?.message || err2}`,
+                detail: { label, error: String(err2?.message || err2), stack: err2?.stack },
+            });
+            throw err2;
+        }
+    }
+}
 const V2_PAIR_ABI = [
     'function token0() view returns (address)',
     'function token1() view returns (address)',
@@ -30,17 +55,17 @@ class PoolStateInitializer {
                 poolContract.token0(),
                 poolContract.token1(),
             ]);
-            const fee = AMM_FEE_MAP[dexId] || AMM_FEE_MAP[dexId.replace('-', '_')] || 30;
+            const feeRateBps = AMM_FEE_MAP[dexId] || AMM_FEE_MAP[dexId.replace('-', '_')] || 30;
             const state = {
                 address: poolAddress,
                 token0: token0.toLowerCase(),
                 token1: token1.toLowerCase(),
-                fee,
+                feeRateBps,
                 reserve0: reserves[0].toString(),
                 reserve1: reserves[1].toString(),
             };
             (0, ttd_core_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
-                token0: state.token0, token1: state.token1, fee: state.fee,
+                token0: state.token0, token1: state.token1, feeRateBps: state.feeRateBps,
             });
             return state;
         }
@@ -62,11 +87,13 @@ class PoolStateInitializer {
                 poolContract.liquidity(),
             ]);
             const [sqrtPriceX96, tick] = slot0;
+            const feeRatePpm = Number(fee);
             const state = {
                 address: poolAddress,
                 token0: token0.toLowerCase(),
                 token1: token1.toLowerCase(),
-                fee: Number(fee),
+                feeRateBps: feeRatePpm / 100,
+                feeRatePpm,
                 tickSpacing: Number(tickSpacing),
                 tick: Number(tick),
                 sqrtPriceX96: sqrtPriceX96.toString(),
@@ -74,7 +101,8 @@ class PoolStateInitializer {
             };
             (0, ttd_core_1.log_info)(`[PoolStateInitializer] CLMM pool initialized: ${poolAddress}`, {
                 token0: state.token0, token1: state.token1,
-                fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
+                feeRateBps: state.feeRateBps, feeRatePpm: state.feeRatePpm,
+                tickSpacing: state.tickSpacing, tick: state.tick,
             });
             return state;
         }
@@ -98,7 +126,8 @@ class PoolStateInitializer {
                 address: poolKey,
                 token0: currency0.toLowerCase ? currency0.toLowerCase() : currency0,
                 token1: currency1.toLowerCase ? currency1.toLowerCase() : currency1,
-                fee: Number(fee),
+                feeRateBps: (Number(lpFee) + Number(protocolFee)) / 100,
+                feeRatePpm: Number(fee),
                 tickSpacing,
                 tick: Number(tick),
                 sqrtPriceX96: sqrtPriceX96.toString(),
@@ -113,7 +142,8 @@ class PoolStateInitializer {
             };
             (0, ttd_core_1.log_info)(`[PoolStateInitializer] Infinity pool initialized: ${poolKey}`, {
                 currency0: state.currency0, currency1: state.currency1,
-                fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
+                feeRateBps: state.feeRateBps, feeRatePpm: state.feeRatePpm,
+                tickSpacing: state.tickSpacing, tick: state.tick,
                 lpFee: state.lpFee, protocolFee: state.protocolFee,
             });
             return state;

package/dist/quote/verify/quote_price_verify.d.ts

@@ -1,3 +1,4 @@
+import { QuoteTier } from '@clonegod/ttd-core';
 export interface CheckSwapParams {
     poolAddress: string;
     poolName: string;
@@ -19,7 +20,10 @@ export interface CheckSwapParams {
 export declare class QuotePriceVerify {
     private quoteCache;
     private get enabled();
-    cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number): void;
+    cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number, tiers?: {
+        askTiers?: QuoteTier[];
+        bidTiers?: QuoteTier[];
+    }): void;
     checkSwap(params: CheckSwapParams): void;
     private deriveSwapDirection;
     private compareAndLog;