@clonegod/ttd-bsc-common 3.1.66 → 3.1.67

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;

package/dist/quote/verify/quote_price_verify.js

@@ -3,6 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuotePriceVerify = void 0;
 const trade_direction_1 = require("../../utils/trade_direction");
 const ttd_core_1 = require("@clonegod/ttd-core");
+function pickMatchingTier(tiers, actualAmountIn) {
+    if (!tiers || tiers.length === 0)
+        return null;
+    if (tiers.length === 1)
+        return { tier: tiers[0], mode: 'single_tier' };
+    const sorted = [...tiers].sort((a, b) => a.amount_in - b.amount_in);
+    const top = sorted[sorted.length - 1];
+    if (actualAmountIn < sorted[0].amount_in) {
+        return { tier: sorted[0], mode: 'extrapolated_low' };
+    }
+    if (actualAmountIn > top.amount_in) {
+        return { tier: top, mode: 'extrapolated_high' };
+    }
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const lower = sorted[i];
+        const upper = sorted[i + 1];
+        if (actualAmountIn >= lower.amount_in && actualAmountIn <= upper.amount_in) {
+            if (actualAmountIn === lower.amount_in)
+                return { tier: lower, mode: 'exact' };
+            if (actualAmountIn === upper.amount_in)
+                return { tier: upper, mode: 'exact' };
+            const span = upper.amount_in - lower.amount_in;
+            if (span <= 0)
+                return { tier: lower, mode: 'exact' };
+            const ratio = (actualAmountIn - lower.amount_in) / span;
+            const lerp = (a, b) => a + ratio * (b - a);
+            return {
+                tier: {
+                    pct: lerp(lower.pct, upper.pct),
+                    price: lerp(lower.price, upper.price),
+                    amount: lerp(lower.amount, upper.amount),
+                    amount_in: actualAmountIn,
+                    amount_in_usd: lerp(lower.amount_in_usd, upper.amount_in_usd),
+                    fee: lerp(lower.fee, upper.fee),
+                    fee_usd: lerp(lower.fee_usd, upper.fee_usd),
+                },
+                mode: 'interpolated',
+            };
+        }
+    }
+    return { tier: top, mode: 'extrapolated_high' };
+}
 class QuotePriceVerify {
     constructor() {
         this.quoteCache = new Map();
@@ -10,7 +52,7 @@ class QuotePriceVerify {
     get enabled() {
         return process.env.VERIFY_QUOTE_PRICE === 'true';
     }
-    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0) {
+    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0, tiers) {
         if (!this.enabled)
             return;
         if (!source)
@@ -26,6 +68,8 @@ class QuotePriceVerify {
             : 0;
         sourceMap.set(source, {
             priceId, source, askPrice, bidPrice,
+            askTiers: tiers?.askTiers,
+            bidTiers: tiers?.bidTiers,
             referenceBlock: blockNumber,
             verifiedReferenceBlock,
             quoteAmountUsd,
@@ -55,12 +99,28 @@ class QuotePriceVerify {
                 continue;
             if (cached.verifiedReferenceBlock === cached.referenceBlock)
                 continue;
-            const refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            const tiers = isBuy ? cached.askTiers : cached.bidTiers;
+            let refPrice;
+            let tierInfo;
+            if (tiers && tiers.length > 0) {
+                const match = pickMatchingTier(tiers, swapData.inputAmountUi);
+                if (!match)
+                    continue;
+                refPrice = match.tier.price;
+                tierInfo = {
+                    matched_pct: parseFloat(match.tier.pct.toFixed(4)),
+                    mode: match.mode,
+                    tier_amount_in: match.tier.amount_in,
+                };
+            }
+            else {
+                refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            }
             if (refPrice <= 0)
                 continue;
             cached.verifiedReferenceBlock = cached.referenceBlock;
             const diff_bps = (refPrice - execPrice) / refPrice * 10000;
-            verifiable.push({ source, cached, refPrice, diff_bps });
+            verifiable.push({ source, cached, refPrice, diff_bps, tierInfo });
         }
         if (verifiable.length === 0)
             return;
@@ -73,9 +133,14 @@ class QuotePriceVerify {
                 bid: r.cached.bidPrice,
                 diff_bps: parseFloat(r.diff_bps.toFixed(1)),
                 quote_block: r.cached.referenceBlock,
+                ...(r.tierInfo && {
+                    matched_pct: r.tierInfo.matched_pct,
+                    tier_mode: r.tierInfo.mode,
+                    tier_amount_in: r.tierInfo.tier_amount_in,
+                }),
             };
         }
-        this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources);
+        this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.refPrice, execPrice, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources, primary.tierInfo);
     }
     deriveSwapDirection(params) {
         const { amount0, amount1, token0Address, token1Address, token0Decimals, token1Decimals } = params;
@@ -102,7 +167,7 @@ class QuotePriceVerify {
         }
         return null;
     }
-    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources) {
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, refPrice, execPriceNum, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources, primaryTierInfo) {
         if (inputAmountUi <= 0 || outputAmountUi <= 0)
             return;
         let swapUsd = 0;
@@ -117,9 +182,6 @@ class QuotePriceVerify {
         const quoteToken = direction.quoteToken;
         const inputIsQuoteToken = inputTokenAddress.toLowerCase() === quoteToken.address.toLowerCase();
         const isBuy = inputIsQuoteToken;
-        const execPrice = (0, trade_direction_1.calculateStandardPrice)(inputAmountUi, outputAmountUi, isBuy);
-        const execPriceNum = Number(execPrice);
-        const refPrice = isBuy ? cached.askPrice : cached.bidPrice;
         const side = isBuy ? 'BUY' : 'SELL';
         if (refPrice <= 0 || execPriceNum <= 0)
             return;
@@ -164,6 +226,11 @@ class QuotePriceVerify {
                 status,
                 time: Date.now(),
                 sources: sources || undefined,
+                ...(primaryTierInfo && {
+                    matched_tier_pct: primaryTierInfo.matched_pct,
+                    matched_tier_mode: primaryTierInfo.mode,
+                    matched_tier_amount_in: primaryTierInfo.tier_amount_in,
+                }),
             });
         }
         catch (_) {

package/dist/trade/abstract_dex_trade.js

@@ -238,6 +238,13 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
         if (!txid) {
             trace.markError('exhaust', `failed after ${maxAttempts} attempts`);
             trace.flush();
+            const groupId = this.appConfig.trade_runtime?.group?.id;
+            ttd_core_1.ALERT_TYPES.TRADE_BUILDER_REJECTED.report({
+                identity: caller.address.toLowerCase(),
+                scope: { caller_address: caller.address.toLowerCase(), group_id: groupId },
+                title: `Trade execution exhausted after ${maxAttempts} attempts (order ${order_trace_id})`,
+                detail: { order_trace_id, attempts: maxAttempts, last_nonce: nonce, last_error_nonce: nonce_from_error },
+            });
             throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
         }
         return txid;

package/dist/trade/check/abstract_tx_result_checker.js

@@ -117,6 +117,12 @@ class AbstractTxResultChecker extends trade_1.AbstractTransactionResultCheck {
                 }
                 else {
                     clearInterval(intervalId);
+                    ttd_core_1.ALERT_TYPES.TRADE_TX_PENDING_TOO_LONG.report({
+                        identity: String(this.txid).toLowerCase(),
+                        scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                        title: `Tx pending > ${check_timeout}ms: ${this.txid}`,
+                        detail: { txid: this.txid, timeout_ms: check_timeout, checks: this.check_count },
+                    });
                 }
             }
             catch (err) {
@@ -155,6 +161,23 @@ class AbstractTxResultChecker extends trade_1.AbstractTransactionResultCheck {
         }
         else {
             this.event_emitter.emit(ttd_core_1.TRANSACTION_STATE_FAILED, trade_result);
+            const status = txReceipt?.status;
+            if (status === 0) {
+                ttd_core_1.ALERT_TYPES.TRADE_VAULT_REVERT.report({
+                    identity: String(this.txid).toLowerCase(),
+                    scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                    title: `Vault revert: tx=${this.txid}`,
+                    detail: { txid: this.txid, status, source, gas_used: txReceipt?.gasUsed?.toString?.() },
+                });
+            }
+            else {
+                ttd_core_1.ALERT_TYPES.TRADE_RESULT_MISSING.report({
+                    identity: String(this.txid).toLowerCase(),
+                    scope: { pool_address: this.pool_info?.pool_address?.toLowerCase() },
+                    title: `TradeResult event missing: tx=${this.txid}`,
+                    detail: { txid: this.txid, status, source, parse_result: trade_result },
+                });
+            }
         }
         if (source === 'interval') {
             console.log('--------------------- Transaction Result from Polling ---------------------');

package/dist/types/pool_state.d.ts

@@ -2,7 +2,7 @@ export interface OnchainPoolData {
     address: string;
     token0: string;
     token1: string;
-    fee: number;
+    feeRateBps: number;
     tickSpacing: number;
     reserve0: string;
     reserve1: string;
@@ -14,7 +14,7 @@ export interface AmmPoolState {
     address: string;
     token0: string;
     token1: string;
-    fee: number;
+    feeRateBps: number;
     reserve0: string;
     reserve1: string;
 }
@@ -22,7 +22,8 @@ export interface ClmmPoolState {
     address: string;
     token0: string;
     token1: string;
-    fee: number;
+    feeRateBps: number;
+    feeRatePpm: number;
     tickSpacing: number;
     tick: number;
     sqrtPriceX96: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.1.66",
+  "version": "3.1.67",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.55",
+    "@clonegod/ttd-core": "3.1.57",
     "axios": "1.15.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",