@clonegod/ttd-bsc-common 3.0.55 → 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/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.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",