@clonegod/ttd-bsc-common 3.0.55 → 3.1.2

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

@@ -3,6 +3,9 @@ export { calculateClmmDepth, getSqrtRatioAtTick, computeTargetSqrtPrice, bigIntS
 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[];
@@ -25,7 +28,11 @@ export interface BuildClmmDepthInput {
     basePriceUsd: number;
     quotePriceUsd: number;
 }
-export declare function buildClmmDepth(input: BuildClmmDepthInput): PoolDepthData | undefined;
+export interface ClmmDepthResult {
+    depth: PoolDepthData;
+    tickLiquidity?: TickLiquiditySnapshot;
+}
+export declare function buildClmmDepth(input: BuildClmmDepthInput): ClmmDepthResult | undefined;
 export interface BuildAmmDepthInput {
     poolInfo: {
         pool_name: string;

package/dist/quote/depth/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmmDepth = exports.bigIntSqrt = exports.computeTargetSqrtPrice = exports.getSqrtRatioAtTick = exports.calculateClmmDepth = void 0;
+exports.buildTickLiquiditySnapshot = exports.calculateAmmDepth = exports.bigIntSqrt = exports.computeTargetSqrtPrice = exports.getSqrtRatioAtTick = exports.calculateClmmDepth = void 0;
 exports.getDepthBps = getDepthBps;
 exports.buildClmmDepth = buildClmmDepth;
 exports.buildAmmDepth = buildAmmDepth;
@@ -15,18 +15,30 @@ Object.defineProperty(exports, "computeTargetSqrtPrice", { enumerable: true, get
 Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function () { return clmm_depth_calculator_2.bigIntSqrt; } });
 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] DEPTH_BPS_LEVELS=${raw || 'undefined'}, bpsLevels=${JSON.stringify(levels)}`);
+        (0, ttd_core_1.log_info)(`[Depth] bpsLevels=${JSON.stringify(levels)}, cexBps=${cexBps}`);
     }
     return levels;
 }
+const _tickLiquidityLastBuild = new Map();
 function buildClmmDepth(input) {
     const bpsLevels = getDepthBps();
     if (bpsLevels.length === 0)
@@ -66,7 +78,38 @@ function buildClmmDepth(input) {
             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 };
         }
-        return depth;
+        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 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;
+            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}`, '');

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;

package/dist/quote/depth/tick_liquidity_snapshot.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTickLiquiditySnapshot = buildTickLiquiditySnapshot;
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+const Q96 = 1n << 96n;
+const DEFAULT_RANGE_BPS = 200;
+function buildTickLiquiditySnapshot(input) {
+    const { poolAddress, pair, protocolId, tickCache, currentTick, tickSpacing, token0, token1, baseIsToken0, token0PriceUsd, token1PriceUsd, } = input;
+    const currentSqrtPriceX96 = BigInt(input.sqrtPriceX96);
+    const currentLiquidity = BigInt(input.liquidity);
+    const rangeBps = input.rangeBps ?? DEFAULT_RANGE_BPS;
+    if (currentLiquidity === 0n)
+        return undefined;
+    const allTickIndices = tickCache.getCachedTickIndices(poolAddress);
+    if (allTickIndices.length === 0)
+        return undefined;
+    const upperSqrtPrice = (0, clmm_depth_calculator_1.computeTargetSqrtPrice)(currentSqrtPriceX96, rangeBps, false);
+    const lowerSqrtPrice = (0, clmm_depth_calculator_1.computeTargetSqrtPrice)(currentSqrtPriceX96, rangeBps, true);
+    const upperTick = sqrtPriceToTick(upperSqrtPrice);
+    const lowerTick = sqrtPriceToTick(lowerSqrtPrice);
+    const ticksInRange = allTickIndices.filter(t => t >= lowerTick && t <= upperTick);
+    if (ticksInRange.length === 0)
+        return undefined;
+    const liquidityMap = computeLiquidityAtTicks(ticksInRange, currentTick, currentLiquidity, tickCache, poolAddress);
+    const tickDataPoints = [];
+    let totalTvlUsd = 0;
+    for (let i = 0; i < ticksInRange.length - 1; i++) {
+        const tickLower = ticksInRange[i];
+        const tickUpper = ticksInRange[i + 1];
+        const liq = liquidityMap.get(tickLower) ?? 0n;
+        if (liq <= 0n) {
+            const price0 = tickToPrice(tickLower, token0.decimals, token1.decimals);
+            const price1 = price0 > 0 ? 1 / price0 : 0;
+            tickDataPoints.push({
+                tick: tickLower,
+                price0, price1,
+                liquidity: '0',
+                amount0: 0, amount1: 0, tvlUsd: 0,
+                buyable: 0, sellable: 0,
+            });
+            continue;
+        }
+        const sqrtPriceLower = (0, clmm_depth_calculator_1.getSqrtRatioAtTick)(tickLower);
+        const sqrtPriceUpper = (0, clmm_depth_calculator_1.getSqrtRatioAtTick)(tickUpper);
+        const { amount0, amount1 } = computeTokenAmounts(sqrtPriceLower, sqrtPriceUpper, currentSqrtPriceX96, liq, token0.decimals, token1.decimals);
+        const tvlUsd = amount0 * token0PriceUsd + amount1 * token1PriceUsd;
+        totalTvlUsd += tvlUsd;
+        const { buyable, sellable } = computeBuySell(sqrtPriceLower, sqrtPriceUpper, liq, token0.decimals, token1.decimals, baseIsToken0);
+        const price0 = tickToPrice(tickLower, token0.decimals, token1.decimals);
+        const price1 = price0 > 0 ? 1 / price0 : 0;
+        tickDataPoints.push({
+            tick: tickLower,
+            price0, price1,
+            liquidity: liq.toString(),
+            amount0, amount1, tvlUsd,
+            buyable, sellable,
+        });
+    }
+    const currentPriceFloat = Number(currentSqrtPriceX96) / Number(Q96);
+    const currentPrice = (currentPriceFloat * currentPriceFloat) *
+        Math.pow(10, token0.decimals - token1.decimals);
+    return {
+        poolAddress,
+        pair,
+        protocolId,
+        currentTick,
+        tickSpacing,
+        currentPrice,
+        token0,
+        token1,
+        ticks: tickDataPoints,
+        totalTvlUsd,
+        timestamp: Date.now(),
+    };
+}
+function computeLiquidityAtTicks(sortedTicks, currentTick, currentLiquidity, tickCache, poolAddress) {
+    const result = new Map();
+    let splitIdx = sortedTicks.findIndex(t => t > currentTick);
+    if (splitIdx === -1)
+        splitIdx = sortedTicks.length;
+    let liq = currentLiquidity;
+    for (let i = splitIdx; i < sortedTicks.length; i++) {
+        const tick = sortedTicks[i];
+        const netLiq = tickCache.getTickLiquidityNet(poolAddress, tick) ?? 0n;
+        liq = liq + netLiq;
+        result.set(tick, liq > 0n ? liq : 0n);
+    }
+    liq = currentLiquidity;
+    for (let i = splitIdx - 1; i >= 0; i--) {
+        const tick = sortedTicks[i];
+        result.set(tick, liq > 0n ? liq : 0n);
+        const netLiq = tickCache.getTickLiquidityNet(poolAddress, tick) ?? 0n;
+        liq = liq - netLiq;
+    }
+    return result;
+}
+function computeTokenAmounts(sqrtPriceLower, sqrtPriceUpper, currentSqrtPrice, liquidity, decimals0, decimals1) {
+    let amount0Wei = 0n;
+    let amount1Wei = 0n;
+    if (currentSqrtPrice <= sqrtPriceLower) {
+        amount0Wei = calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity);
+    }
+    else if (currentSqrtPrice >= sqrtPriceUpper) {
+        amount1Wei = calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity);
+    }
+    else {
+        amount0Wei = calcToken0Amount(currentSqrtPrice, sqrtPriceUpper, liquidity);
+        amount1Wei = calcToken1Amount(sqrtPriceLower, currentSqrtPrice, liquidity);
+    }
+    return {
+        amount0: Number(amount0Wei) / Math.pow(10, decimals0),
+        amount1: Number(amount1Wei) / Math.pow(10, decimals1),
+    };
+}
+function computeBuySell(sqrtPriceLower, sqrtPriceUpper, liquidity, decimals0, decimals1, baseIsToken0) {
+    const token0Out = Number(calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity)) / Math.pow(10, decimals0);
+    const token1Out = Number(calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity)) / Math.pow(10, decimals1);
+    if (baseIsToken0) {
+        return { buyable: token0Out, sellable: token1Out };
+    }
+    else {
+        return { buyable: token1Out, sellable: token0Out };
+    }
+}
+function calcToken0Amount(sqrtPriceLower, sqrtPriceUpper, liquidity) {
+    if (sqrtPriceLower >= sqrtPriceUpper || liquidity === 0n)
+        return 0n;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    return liquidity * diff * Q96 / (sqrtPriceLower * sqrtPriceUpper);
+}
+function calcToken1Amount(sqrtPriceLower, sqrtPriceUpper, liquidity) {
+    if (sqrtPriceLower >= sqrtPriceUpper || liquidity === 0n)
+        return 0n;
+    const diff = sqrtPriceUpper - sqrtPriceLower;
+    return liquidity * diff / Q96;
+}
+function sqrtPriceToTick(sqrtPriceX96) {
+    const sqrtPriceFloat = Number(sqrtPriceX96) / Number(Q96);
+    return Math.floor(Math.log(sqrtPriceFloat * sqrtPriceFloat) / Math.log(1.0001));
+}
+function tickToPrice(tick, decimals0, decimals1) {
+    return Math.pow(1.0001, tick) * Math.pow(10, decimals0 - decimals1);
+}

package/dist/quote/tick/clmm_tick_cache.d.ts

@@ -1,3 +1,4 @@
+export declare const TICK_REFRESH_INTERVAL_MS: number;
 export interface TickInfo {
     liquidityNet: bigint;
     liquidityGross: bigint;

package/dist/quote/tick/clmm_tick_cache.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClmmTickCache = void 0;
+exports.ClmmTickCache = exports.TICK_REFRESH_INTERVAL_MS = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+exports.TICK_REFRESH_INTERVAL_MS = Number(process.env.TICK_CACHE_FORCE_FULL_REFRESH_INTERVAL) || 60000;
 class ClmmTickCache {
     constructor(loader, config = {}) {
         this.pools = new Map();
@@ -10,7 +11,7 @@ class ClmmTickCache {
         this.loader = loader;
         this.config = {
             neighboringWords: config.neighboringWords ?? (Number(process.env.TICK_CACHE_NEIGHBORING_WORDS) || 2),
-            refreshInterval: config.refreshInterval ?? (Number(process.env.TICK_CACHE_FORCE_FULL_REFRESH_INTERVAL) || 60000),
+            refreshInterval: config.refreshInterval ?? exports.TICK_REFRESH_INTERVAL_MS,
             minUpdateInterval: config.minUpdateInterval ?? (Number(process.env.TICK_CACHE_MIN_UPDATE_INTERVAL) || 3000),
         };
     }

package/dist/trade/abstract_dex_trade.js

@@ -180,6 +180,8 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 await this.transactionSender.sendTransaction(signedMainTx, tipTxMap, order_trace_id, pair, only_bundle, trace);
                 trace.mark('sent');
                 trace.flush();
+                context._execution_marks = trace.getAbsoluteMarks();
+                context._execution_start_time = trace.getStartTime();
                 try {
                     base_tx_result_checker_1.TradeResultSubscriber.getInstance().sendNonceWatch(caller.address, txid);
                 }

package/dist/trade/caller_manager.js

@@ -62,32 +62,55 @@ class CallerManager {
         logger.info(`CallerManager initialized for ${this.config.groupId}: loaded=${allWallets.length}, active=${this.callers.length}, skipped=${skipped.length}`, callerSummary);
     }
     async acquireCaller() {
-        const addresses = this.callers.map(w => w.address.toLowerCase());
-        const lastUsedKey = this.getLastUsedRedisKey();
-        const nonceKey = this.getNonceRedisKey();
-        const [lastUsedData, nonceValues] = await Promise.all([
-            this.redis.hgetall(lastUsedKey),
-            this.redis.hmget(nonceKey, addresses),
-        ]);
-        let selectedIdx = 0;
-        let minLastUsed = Number.MAX_SAFE_INTEGER;
-        for (let i = 0; i < this.callers.length; i++) {
-            const redisTs = parseInt(lastUsedData?.[addresses[i]] || '0', 10);
-            if (redisTs < minLastUsed) {
-                minLastUsed = redisTs;
-                selectedIdx = i;
+        const lockKey = `${this.config.chainName}:caller:lock:select`;
+        const lockValue = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const lockExpireSeconds = 1;
+        const maxRetries = 20;
+        const retryDelayMs = 10;
+        const startTime = Date.now();
+        let acquired = false;
+        let retries = 0;
+        for (; retries < maxRetries; retries++) {
+            acquired = await this.redis.acquireLock(lockKey, lockValue, lockExpireSeconds);
+            if (acquired)
+                break;
+            await new Promise(r => setTimeout(r, retryDelayMs));
+        }
+        if (!acquired) {
+            throw new Error(`acquireCaller: failed to acquire lock after ${maxRetries} retries (${Date.now() - startTime}ms)`);
+        }
+        const lockAcquiredTime = Date.now();
+        let callerAddr;
+        let selectedIdx;
+        try {
+            const addresses = this.callers.map(w => w.address.toLowerCase());
+            const lastUsedKey = this.getLastUsedRedisKey();
+            const lastUsedData = await this.redis.hgetall(lastUsedKey);
+            selectedIdx = 0;
+            let minLastUsed = Number.MAX_SAFE_INTEGER;
+            for (let i = 0; i < this.callers.length; i++) {
+                const redisTs = parseInt(lastUsedData?.[addresses[i]] || '0', 10);
+                if (redisTs < minLastUsed) {
+                    minLastUsed = redisTs;
+                    selectedIdx = i;
+                }
             }
+            callerAddr = addresses[selectedIdx];
+            await this.redis.hsetValue(lastUsedKey, callerAddr, String(Date.now()), 24 * 60 * 60);
         }
-        const caller = this.callers[selectedIdx];
-        const callerAddr = addresses[selectedIdx];
-        const nonceStr = nonceValues[selectedIdx];
+        finally {
+            this.redis.releaseLock(lockKey, lockValue).catch(() => { });
+        }
+        const nonceKey = this.getNonceRedisKey();
+        const nonceStr = await this.redis.hgetvalue(nonceKey, callerAddr);
         if (nonceStr === null || nonceStr === undefined) {
-            throw new Error(`Caller ${caller.address} nonce not found in Redis, stream-trade may not be running`);
+            throw new Error(`Caller ${callerAddr} nonce not found in Redis, stream-trade may not be running`);
         }
         const nonce = parseInt(nonceStr, 10);
-        this.redis.hsetValue(lastUsedKey, callerAddr, String(Date.now()), 24 * 60 * 60)
-            .catch(err => logger.warn(`updateLastUsed failed: ${err.message}`));
-        return { wallet: caller, nonce };
+        const totalMs = Date.now() - startTime;
+        const lockWaitMs = lockAcquiredTime - startTime;
+        logger.info(`acquireCaller: ${callerAddr} nonce=${nonce}, lock_wait=${lockWaitMs}ms, total=${totalMs}ms${retries > 0 ? `, retries=${retries}` : ''}`);
+        return { wallet: this.callers[selectedIdx], nonce };
     }
     async confirmNonce(address, confirmedNonce) {
         const current = await this.getNonce(address);

package/dist/trade/trade_trace.d.ts

@@ -11,5 +11,7 @@ export declare class TradeTrace {
     set(key: string, value: any): void;
     markError(stage: string, message: string): void;
     private buildTimeline;
+    getAbsoluteMarks(): Record<string, number>;
+    getStartTime(): number;
     flush(): void;
 }

package/dist/trade/trade_trace.js

@@ -34,6 +34,16 @@ class TradeTrace {
         const total = this.marks[this.marks.length - 1].elapsed;
         return `recv -> ${parts.join(' -> ')} = ${total}ms`;
     }
+    getAbsoluteMarks() {
+        const result = {};
+        for (const m of this.marks) {
+            result[m.name] = this.startTime + m.elapsed;
+        }
+        return result;
+    }
+    getStartTime() {
+        return this.startTime;
+    }
     flush() {
         const timeline = this.buildTimeline();
         if (this.error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.0.55",
+  "version": "3.1.2",
   "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.0.21",
+    "@clonegod/ttd-core": "3.1.2",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",