@clonegod/ttd-bsc-common 3.0.54 → 3.1.1

package/dist/quote/depth/index.js

@@ -16,14 +16,21 @@ Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function (
 var amm_depth_calculator_2 = require("./amm_depth_calculator");
 Object.defineProperty(exports, "calculateAmmDepth", { enumerable: true, get: function () { return amm_depth_calculator_2.calculateAmmDepth; } });
 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;
 }

package/dist/quote/index.d.ts

@@ -2,6 +2,6 @@ export * from './event';
 export * from './pricing';
 export * from './tick';
 export * from './depth';
-export * from './accuracy';
+export * from './verify';
 export * from './price_feed_handler';
 export * from './quote_amount';

package/dist/quote/index.js

@@ -18,6 +18,6 @@ __exportStar(require("./event"), exports);
 __exportStar(require("./pricing"), exports);
 __exportStar(require("./tick"), exports);
 __exportStar(require("./depth"), exports);
-__exportStar(require("./accuracy"), exports);
+__exportStar(require("./verify"), exports);
 __exportStar(require("./price_feed_handler"), exports);
 __exportStar(require("./quote_amount"), exports);

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

@@ -0,0 +1,2 @@
+export { QuotePriceVerify } from './quote_price_verify';
+export type { CheckSwapParams, CheckSyncParams } from './quote_price_verify';

package/dist/quote/verify/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+var quote_price_verify_1 = require("./quote_price_verify");
+Object.defineProperty(exports, "QuotePriceVerify", { enumerable: true, get: function () { return quote_price_verify_1.QuotePriceVerify; } });

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

@@ -0,0 +1,42 @@
+export interface CheckSwapParams {
+    poolAddress: string;
+    poolName: string;
+    blockNumber: number;
+    txHash: string;
+    amount0: string;
+    amount1: string;
+    token0Address: string;
+    token1Address: string;
+    token0Decimals: number;
+    token1Decimals: number;
+    poolInfo: {
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+}
+export interface CheckSyncParams {
+    poolAddress: string;
+    poolName: string;
+    blockNumber: number;
+    reserve0: string;
+    reserve1: string;
+    token0Address: string;
+    token1Address: string;
+    token0Decimals: number;
+    token1Decimals: number;
+    poolInfo: {
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+}
+export declare class QuotePriceVerify {
+    private quoteCache;
+    private reserveCache;
+    private get enabled();
+    cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number): void;
+    checkSwap(params: CheckSwapParams): void;
+    checkSync(params: CheckSyncParams): void;
+    private compareAndLog;
+}

package/dist/quote/verify/quote_price_verify.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+const trade_direction_1 = require("../../utils/trade_direction");
+class QuotePriceVerify {
+    constructor() {
+        this.quoteCache = new Map();
+        this.reserveCache = new Map();
+    }
+    get enabled() {
+        return process.env.VERIFY_QUOTE_PRICE === 'true';
+    }
+    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0) {
+        if (!this.enabled)
+            return;
+        this.quoteCache.set(poolAddress, {
+            priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd,
+            verifiedBlock: 0,
+            token0PriceUsd, token1PriceUsd,
+        });
+    }
+    checkSwap(params) {
+        if (!this.enabled)
+            return;
+        const { poolAddress, poolName, blockNumber, txHash, amount0, amount1, poolInfo } = params;
+        const { token0Address, token1Address, token0Decimals, token1Decimals } = params;
+        const cached = this.quoteCache.get(poolAddress);
+        if (!cached)
+            return;
+        if (blockNumber <= cached.blockNumber)
+            return;
+        if (blockNumber <= cached.verifiedBlock)
+            return;
+        cached.verifiedBlock = blockNumber;
+        const amt0 = BigInt(amount0);
+        const amt1 = BigInt(amount1);
+        if (amt0 === 0n && amt1 === 0n)
+            return;
+        let inputTokenAddress;
+        let outputTokenAddress;
+        let inputAmountUi;
+        let outputAmountUi;
+        if (amt0 > 0n && amt1 < 0n) {
+            inputTokenAddress = token0Address;
+            outputTokenAddress = token1Address;
+            inputAmountUi = Number(amt0) / Math.pow(10, token0Decimals);
+            outputAmountUi = Number(-amt1) / Math.pow(10, token1Decimals);
+        }
+        else if (amt0 < 0n && amt1 > 0n) {
+            inputTokenAddress = token1Address;
+            outputTokenAddress = token0Address;
+            inputAmountUi = Number(amt1) / Math.pow(10, token1Decimals);
+            outputAmountUi = Number(-amt0) / Math.pow(10, token0Decimals);
+        }
+        else {
+            return;
+        }
+        this.compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, cached.token0PriceUsd, cached.token1PriceUsd, token0Address, blockNumber, txHash);
+    }
+    checkSync(params) {
+        if (!this.enabled)
+            return;
+        const { poolAddress, poolName, blockNumber, reserve0, reserve1, poolInfo } = params;
+        const { token0Address, token1Address, token0Decimals, token1Decimals } = params;
+        const cached = this.quoteCache.get(poolAddress);
+        if (!cached)
+            return;
+        if (blockNumber <= cached.blockNumber)
+            return;
+        if (blockNumber <= cached.verifiedBlock)
+            return;
+        const newR0 = BigInt(reserve0);
+        const newR1 = BigInt(reserve1);
+        const oldReserves = this.reserveCache.get(poolAddress);
+        this.reserveCache.set(poolAddress, { reserve0: newR0, reserve1: newR1 });
+        if (!oldReserves)
+            return;
+        const delta0 = newR0 - oldReserves.reserve0;
+        const delta1 = newR1 - oldReserves.reserve1;
+        if ((delta0 > 0n && delta1 > 0n) || (delta0 < 0n && delta1 < 0n) || (delta0 === 0n && delta1 === 0n)) {
+            return;
+        }
+        cached.verifiedBlock = blockNumber;
+        let inputTokenAddress;
+        let outputTokenAddress;
+        let inputAmountUi;
+        let outputAmountUi;
+        if (delta0 > 0n && delta1 < 0n) {
+            inputTokenAddress = token0Address;
+            outputTokenAddress = token1Address;
+            inputAmountUi = Number(delta0) / Math.pow(10, token0Decimals);
+            outputAmountUi = Number(-delta1) / Math.pow(10, token1Decimals);
+        }
+        else {
+            inputTokenAddress = token1Address;
+            outputTokenAddress = token0Address;
+            inputAmountUi = Number(delta1) / Math.pow(10, token1Decimals);
+            outputAmountUi = Number(-delta0) / Math.pow(10, token0Decimals);
+        }
+        this.compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, cached.token0PriceUsd, cached.token1PriceUsd, token0Address, blockNumber);
+    }
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash) {
+        if (inputAmountUi <= 0 || outputAmountUi <= 0)
+            return;
+        let swapUsd = 0;
+        if (token0PriceUsd && token1PriceUsd && token0Address) {
+            const inputIsToken0 = inputTokenAddress.toLowerCase() === token0Address.toLowerCase();
+            swapUsd = inputIsToken0
+                ? inputAmountUi * token0PriceUsd
+                : inputAmountUi * token1PriceUsd;
+        }
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = direction.baseToken;
+        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;
+        const diffBps = (execPriceNum - refPrice) / refPrice * 10000;
+        const absDiffBps = Math.abs(diffBps);
+        const status = absDiffBps < 10 ? '✅' : absDiffBps < 30 ? '⚠️' : '❌';
+        const usdStr = swapUsd > 0 ? `$${swapUsd.toFixed(0)}` : '$?';
+        const minUsd = cached.quoteAmountUsd * 0.5;
+        const maxUsd = cached.quoteAmountUsd * 2;
+        const inRange = swapUsd <= 0 || (swapUsd >= minUsd && swapUsd <= maxUsd);
+        const rangeTag = inRange ? '' : ' [out]';
+        const tradeFlow = isBuy
+            ? `${inputAmountUi.toFixed(4)} ${quoteToken.symbol} -> ${outputAmountUi.toFixed(4)} ${baseToken.symbol}`
+            : `${inputAmountUi.toFixed(4)} ${baseToken.symbol} -> ${outputAmountUi.toFixed(4)} ${quoteToken.symbol}`;
+        const quoteSrc = cached.source || '?';
+        const quoteTag = `quote[${quoteSrc} blk:${cached.blockNumber}]`;
+        const swapBlk = swapBlockNumber || '?';
+        const swapTx = txHash ? ` ${txHash.slice(0, 10)}` : '';
+        const swapTag = `swap[blk:${swapBlk}${swapTx}]`;
+        const priceLabel = isBuy ? 'ask' : 'bid';
+        const msg = `  ↳ [Verify] ${side} ${usdStr} (${tradeFlow}) ${quoteTag} ${priceLabel}=${refPrice.toFixed(12)} vs ${swapTag} exec=${execPriceNum.toFixed(12)} diff=${diffBps > 0 ? '+' : ''}${diffBps.toFixed(1)}bps ${status}${rangeTag}`;
+        console.log(msg);
+    }
+}
+exports.QuotePriceVerify = QuotePriceVerify;

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.54",
+  "version": "3.1.1",
   "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.1",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",