@clonegod/ttd-bsc-common 3.0.10 → 3.0.12

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

@@ -0,0 +1,12 @@
+import { ClmmTickCache } from './clmm_tick_cache';
+export declare class CachedTickDataProvider {
+    private tickCache;
+    private poolAddress;
+    private tickSpacing;
+    constructor(tickCache: ClmmTickCache, poolAddress: string, tickSpacing: number);
+    getTick(tick: number): Promise<{
+        liquidityNet: string;
+        liquidityGross: string;
+    }>;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}

package/dist/quote/tick/cached_tick_data_provider.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedTickDataProvider = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const MIN_TICK = -887272;
+const MAX_TICK = 887272;
+class CachedTickDataProvider {
+    constructor(tickCache, poolAddress, tickSpacing) {
+        this.tickCache = tickCache;
+        this.poolAddress = poolAddress;
+        this.tickSpacing = tickSpacing;
+    }
+    getTick(tick) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tickInfo = this.tickCache.getTickInfo(this.poolAddress, tick);
+            if (tickInfo) {
+                return {
+                    liquidityNet: tickInfo.liquidityNet.toString(),
+                    liquidityGross: tickInfo.liquidityGross.toString(),
+                };
+            }
+            (0, ttd_core_1.log_warn)(`[CachedTickDataProvider] tick ${tick} not in cache for pool ${this.poolAddress}`);
+            return {
+                liquidityNet: '0',
+                liquidityGross: '0',
+            };
+        });
+    }
+    nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const zeroForOne = !lte;
+            const result = this.tickCache.getNextInitializedTickWithinOneWord(this.poolAddress, tick, tickSpacing, zeroForOne);
+            if (result)
+                return result;
+            const compressed = Math.floor(tick / tickSpacing);
+            if (lte) {
+                const wordPos = compressed >> 8;
+                const minimum = (wordPos << 8) * tickSpacing;
+                return [Math.max(minimum, MIN_TICK), false];
+            }
+            else {
+                const wordPos = (compressed + 1) >> 8;
+                const maximum = (((wordPos + 1) << 8) - 1) * tickSpacing;
+                return [Math.min(maximum, MAX_TICK), false];
+            }
+        });
+    }
+}
+exports.CachedTickDataProvider = CachedTickDataProvider;

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

@@ -35,6 +35,7 @@ export declare class ClmmTickCache {
     private getBitmapIndex;
     private calcBitmapIndexes;
     private isInCachedRange;
+    getNextInitializedTickWithinOneWord(poolAddress: string, tick: number, tickSpacing: number, zeroForOne: boolean): [number, boolean] | null;
     clearPool(poolAddress: string): void;
     destroy(): void;
 }

package/dist/quote/tick/clmm_tick_cache.js

@@ -20,7 +20,7 @@ class ClmmTickCache {
         this.loader = loader;
         this.config = {
             neighboringWords: (_a = config.neighboringWords) !== null && _a !== void 0 ? _a : 2,
-            refreshInterval: (_b = config.refreshInterval) !== null && _b !== void 0 ? _b : 30000,
+            refreshInterval: (_b = config.refreshInterval) !== null && _b !== void 0 ? _b : 60000,
             minUpdateInterval: (_c = config.minUpdateInterval) !== null && _c !== void 0 ? _c : 3000,
         };
     }
@@ -201,6 +201,32 @@ class ClmmTickCache {
         const bitmapIndex = this.getBitmapIndex(tickIndex, state.tickSpacing);
         return state.bitmapIndexes.includes(bitmapIndex);
     }
+    getNextInitializedTickWithinOneWord(poolAddress, tick, tickSpacing, zeroForOne) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return null;
+        const compressed = Math.floor(tick / tickSpacing);
+        const wordPos = compressed >> 8;
+        const wordStartTick = (wordPos << 8) * tickSpacing;
+        const wordEndTick = ((wordPos + 1) << 8) * tickSpacing;
+        const ticksInWord = Array.from(state.ticks.keys())
+            .filter(t => t >= wordStartTick && t < wordEndTick)
+            .sort((a, b) => a - b);
+        if (ticksInWord.length === 0)
+            return null;
+        if (zeroForOne) {
+            const nextTick = ticksInWord.find(t => t > tick);
+            if (nextTick !== undefined)
+                return [nextTick, true];
+        }
+        else {
+            for (let i = ticksInWord.length - 1; i >= 0; i--) {
+                if (ticksInWord[i] < tick)
+                    return [ticksInWord[i], true];
+            }
+        }
+        return null;
+    }
     clearPool(poolAddress) {
         this.pools.delete(poolAddress);
         const timer = this.refreshTimers.get(poolAddress);

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

@@ -1,2 +1,4 @@
 export * from './clmm_tick_cache';
 export * from './tick_lens_loaders';
+export * from './cached_tick_data_provider';
+export * from './state_view_tick_loader';

package/dist/quote/tick/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./clmm_tick_cache"), exports);
 __exportStar(require("./tick_lens_loaders"), exports);
+__exportStar(require("./cached_tick_data_provider"), exports);
+__exportStar(require("./state_view_tick_loader"), exports);

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

@@ -0,0 +1,17 @@
+import { TickInfo, TickLensLoader } from './clmm_tick_cache';
+export declare class StateViewTickLensLoader implements TickLensLoader {
+    private ethersLib;
+    private provider;
+    private stateViewAddress;
+    private stateViewIface;
+    private multicallContract;
+    private tickSpacingMap;
+    constructor(params: {
+        ethersLib: any;
+        provider: any;
+        stateViewAddress: string;
+        multicallAddress?: string;
+    });
+    setTickSpacing(poolAddress: string, tickSpacing: number): void;
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+}

package/dist/quote/tick/state_view_tick_loader.js

@@ -0,0 +1,149 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateViewTickLensLoader = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const tick_lens_loaders_1 = require("./tick_lens_loaders");
+const STATE_VIEW_ABI = [
+    {
+        type: 'function',
+        name: 'getTickBitmap',
+        inputs: [
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'tick', type: 'int16' },
+        ],
+        outputs: [
+            { name: 'tickBitmap', type: 'uint256' },
+        ],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'getTickLiquidity',
+        inputs: [
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'tick', type: 'int24' },
+        ],
+        outputs: [
+            { name: 'liquidityGross', type: 'uint128' },
+            { name: 'liquidityNet', type: 'int128' },
+        ],
+        stateMutability: 'view',
+    },
+];
+const MULTICALL3_ABI = [
+    {
+        type: 'function',
+        name: 'aggregate',
+        inputs: [
+            {
+                name: 'calls',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [
+            { name: 'blockNumber', type: 'uint256' },
+            { name: 'returnData', type: 'bytes[]' },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+function getInitializedTicksFromBitmap(bitmapIndex, bitmap, tickSpacing) {
+    const ticks = [];
+    for (let bit = 0; bit < 256; bit++) {
+        if ((bitmap >> BigInt(bit)) & BigInt(1)) {
+            const tickIndex = (bitmapIndex * 256 + bit) * tickSpacing;
+            ticks.push(tickIndex);
+        }
+    }
+    return ticks;
+}
+class StateViewTickLensLoader {
+    constructor(params) {
+        var _a;
+        this.tickSpacingMap = new Map();
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.stateViewAddress = params.stateViewAddress;
+        const InterfaceClass = params.ethersLib.Interface || ((_a = params.ethersLib.utils) === null || _a === void 0 ? void 0 : _a.Interface);
+        if (!InterfaceClass) {
+            throw new Error('ethersLib.Interface not found');
+        }
+        this.stateViewIface = new InterfaceClass(STATE_VIEW_ABI);
+        this.multicallContract = new params.ethersLib.Contract(params.multicallAddress || tick_lens_loaders_1.MULTICALL3_ADDRESS, MULTICALL3_ABI, this.provider);
+    }
+    setTickSpacing(poolAddress, tickSpacing) {
+        this.tickSpacingMap.set(poolAddress.toLowerCase(), tickSpacing);
+    }
+    loadBitmapWords(poolAddress, bitmapIndexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = new Map();
+            if (bitmapIndexes.length === 0)
+                return result;
+            const tickSpacing = this.tickSpacingMap.get(poolAddress.toLowerCase());
+            if (!tickSpacing) {
+                (0, ttd_core_1.log_warn)(`[StateViewLoader] tickSpacing not set for ${poolAddress}, defaulting to 1`);
+            }
+            const spacing = tickSpacing || 1;
+            try {
+                const bitmapCalls = bitmapIndexes.map(bitmapIndex => ({
+                    target: this.stateViewAddress,
+                    callData: this.stateViewIface.encodeFunctionData('getTickBitmap', [poolAddress, bitmapIndex]),
+                }));
+                const callMethod = this.multicallContract.aggregate.staticCall || ((_a = this.multicallContract.callStatic) === null || _a === void 0 ? void 0 : _a.aggregate);
+                const [, bitmapReturnData] = yield callMethod(bitmapCalls);
+                const initializedTicks = [];
+                for (let i = 0; i < bitmapReturnData.length; i++) {
+                    try {
+                        const decoded = this.stateViewIface.decodeFunctionResult('getTickBitmap', bitmapReturnData[i]);
+                        const bitmap = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                        const ticks = getInitializedTicksFromBitmap(bitmapIndexes[i], bitmap, spacing);
+                        initializedTicks.push(...ticks);
+                    }
+                    catch (e) {
+                        (0, ttd_core_1.log_warn)(`[StateViewLoader] Failed to decode bitmap ${bitmapIndexes[i]}: ${e.message}`);
+                    }
+                }
+                if (initializedTicks.length === 0) {
+                    (0, ttd_core_1.log_debug)(`[StateViewLoader] No initialized ticks in ${bitmapIndexes.length} bitmap words`);
+                    return result;
+                }
+                const liquidityCalls = initializedTicks.map(tick => ({
+                    target: this.stateViewAddress,
+                    callData: this.stateViewIface.encodeFunctionData('getTickLiquidity', [poolAddress, tick]),
+                }));
+                const [, liquidityReturnData] = yield callMethod(liquidityCalls);
+                for (let i = 0; i < liquidityReturnData.length; i++) {
+                    try {
+                        const decoded = this.stateViewIface.decodeFunctionResult('getTickLiquidity', liquidityReturnData[i]);
+                        const liquidityGross = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                        const liquidityNet = typeof decoded[1] === 'bigint' ? decoded[1] : BigInt(decoded[1].toString());
+                        result.set(initializedTicks[i], { liquidityNet, liquidityGross });
+                    }
+                    catch (e) {
+                        (0, ttd_core_1.log_warn)(`[StateViewLoader] Failed to decode tick ${initializedTicks[i]}: ${e.message}`);
+                    }
+                }
+                (0, ttd_core_1.log_debug)(`[StateViewLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (2 Multicall3 calls)`);
+            }
+            catch (error) {
+                (0, ttd_core_1.log_warn)(`[StateViewLoader] Multicall failed: ${error.message}`);
+            }
+            return result;
+        });
+    }
+}
+exports.StateViewTickLensLoader = StateViewTickLensLoader;

package/dist/trade/abstract_dex_trade.js

@@ -81,89 +81,93 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 slippage: `${slippage_bps / 100}%`,
             });
             let maxAttempts = Math.min(Math.max(parseInt(process.env.NONCE_LOCK_MAX_RETRIES || '3'), 1), 3);
-            const callerHandle = yield this.callerManager.acquireCaller();
-            const { wallet: caller, nonce: initialNonce } = callerHandle;
-            try {
-                let nonce = initialNonce;
-                let nonce_from_error = -1;
-                let txid = '';
-                let i = 1;
-                do {
-                    try {
-                        if (i > 1) {
-                            if (nonce_from_error >= 0) {
-                                nonce = nonce_from_error;
-                                nonce_from_error = -1;
-                                (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
-                            }
-                            else {
-                                nonce = yield this.provider.getTransactionCount(caller.address, 'pending');
-                                (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from chain: ${nonce}`, {}, order_trace_id);
-                            }
+            const { wallet: caller, nonce: initialNonce } = yield this.callerManager.acquireCaller();
+            let nonce = initialNonce;
+            let nonce_from_error = -1;
+            let txid = '';
+            let i = 1;
+            do {
+                try {
+                    if (i > 1) {
+                        if (nonce_from_error >= 0) {
+                            nonce = nonce_from_error;
+                            nonce_from_error = -1;
+                            (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
                         }
-                        const { executorId, data } = this.encodeTradeData(context);
-                        const deadline = Math.floor(Date.now() / 1000) + 60;
-                        const vaultCalldata = this.vaultInterface.encodeFunctionData('delegatecallExecutorToTrade', [executorId, data, deadline]);
-                        const gasPriceGwei = this.getGasPriceGwei(context);
-                        const realGasPriceGwei = Math.min(Number(gasPriceGwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
-                        const tx = {
-                            to: this.tradeConfig.vaultAddress,
-                            data: vaultCalldata,
-                            gasLimit: this.chainConfig.gasOptions.gasLimit,
-                            gasPrice: ethers_1.ethers.utils.parseUnits(realGasPriceGwei, 'gwei'),
-                            nonce,
-                            chainId: this.chainConfig.chainId,
-                            value: 0,
-                        };
-                        const signedTx = yield caller.signTransaction(tx);
-                        txid = ethers_1.ethers.utils.keccak256(signedTx);
-                        (0, ttd_core_1.log_info)(`交易已签名`, { txid, nonce, caller: caller.address, gasPriceGwei: realGasPriceGwei }, order_trace_id);
-                        const tipNonce = nonce + 1;
-                        const eoa_tip_transaction = (eoa_address) => __awaiter(this, void 0, void 0, function* () {
-                            const transfer_amount_gwei = this.getBuilderTipAmoutGwei(context);
-                            context.ui_tip_amount = new decimal_js_1.default(transfer_amount_gwei).div(Math.pow(10, 9)).toNumber();
-                            return yield this.buildTipTransferTx(eoa_address, transfer_amount_gwei, realGasPriceGwei, tipNonce, caller);
-                        });
-                        const only_bundle = order_msg.is_dex_maker;
-                        yield this.transactionSender.sendTransaction(signedTx, eoa_tip_transaction, order_trace_id, pair, only_bundle);
-                        (0, ttd_core_1.log_info)(`交易发送成功`, {
-                            pair, direction: isBuy ? 'BUY' : 'SELL',
-                            txid, attempt: i, caller: caller.address
-                        }, order_trace_id);
+                        else {
+                            nonce = yield this.provider.getTransactionCount(caller.address, 'pending');
+                            (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from chain: ${nonce}`, {}, order_trace_id);
+                        }
+                    }
+                    const { executorId, data } = this.encodeTradeData(context);
+                    const deadline = Math.floor(Date.now() / 1000) + 60;
+                    const vaultCalldata = this.vaultInterface.encodeFunctionData('delegatecallExecutorToTrade', [executorId, data, deadline]);
+                    const gasPriceGwei = this.getGasPriceGwei(context);
+                    const realGasPriceGwei = Math.min(Number(gasPriceGwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+                    const tipNonce = nonce + 1;
+                    const transfer_amount_gwei = this.getBuilderTipAmoutGwei(context);
+                    context.ui_tip_amount = new decimal_js_1.default(transfer_amount_gwei).div(Math.pow(10, 9)).toNumber();
+                    const mainTx = {
+                        to: this.tradeConfig.vaultAddress,
+                        data: vaultCalldata,
+                        gasLimit: this.chainConfig.gasOptions.gasLimit,
+                        gasPrice: ethers_1.ethers.utils.parseUnits(realGasPriceGwei, 'gwei'),
+                        nonce,
+                        chainId: this.chainConfig.chainId,
+                        value: 0,
+                    };
+                    const builderAddresses = [
+                        ttd_bsc_send_tx_1.BSC_EOA_ADDRESS.BLOCKRAZOR,
+                        ttd_bsc_send_tx_1.BSC_EOA_ADDRESS._48CLUB,
+                        ttd_bsc_send_tx_1.BSC_EOA_ADDRESS.BLXR,
+                    ];
+                    const [signedMainTx, ...signedTips] = yield Promise.all([
+                        caller.signTransaction(mainTx),
+                        ...builderAddresses.map(addr => this.buildTipTransferTx(addr, transfer_amount_gwei, realGasPriceGwei, tipNonce, caller)),
+                    ]);
+                    txid = ethers_1.ethers.utils.keccak256(signedMainTx);
+                    const tipTxMap = new Map();
+                    builderAddresses.forEach((addr, idx) => tipTxMap.set(addr, signedTips[idx]));
+                    (0, ttd_core_1.log_info)(`交易已签名`, { txid, nonce, caller: caller.address, gasPriceGwei: realGasPriceGwei }, order_trace_id);
+                    const only_bundle = order_msg.is_dex_maker;
+                    const eoa_tip_transaction = (eoa_address) => __awaiter(this, void 0, void 0, function* () {
+                        return tipTxMap.get(eoa_address) || (yield this.buildTipTransferTx(eoa_address, transfer_amount_gwei, realGasPriceGwei, tipNonce, caller));
+                    });
+                    yield this.transactionSender.sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id, pair, only_bundle);
+                    (0, ttd_core_1.log_info)(`交易发送成功`, {
+                        pair, direction: isBuy ? 'BUY' : 'SELL',
+                        txid, attempt: i, caller: caller.address
+                    }, order_trace_id);
+                    return txid;
+                }
+                catch (error) {
+                    const errorMessage = ((_a = error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+                    if (errorMessage.includes('rate limit')) {
+                        (0, ttd_core_1.log_warn)(`Rate limit error, no retry! i=${i}`, {}, order_trace_id);
                         return txid;
                     }
-                    catch (error) {
-                        const errorMessage = ((_a = error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
-                        if (errorMessage.includes('rate limit')) {
-                            (0, ttd_core_1.log_warn)(`Rate limit error, no retry! i=${i}`, {}, order_trace_id);
-                            return txid;
-                        }
-                        if (errorMessage.includes('replacement transaction underpriced')) {
-                            (0, ttd_core_1.log_warn)(`Replacement tx underpriced, continue! i=${i}`, {}, order_trace_id);
-                            continue;
-                        }
-                        const isNonceError = errorMessage.includes('nonce');
-                        if (!isNonceError || i >= maxAttempts) {
-                            (0, ttd_core_1.log_warn)(`Non-nonce error or max retries, i=${i}, error: ${errorMessage}`, {}, order_trace_id);
-                            return txid;
-                        }
-                        (0, ttd_core_1.log_info)(`Nonce error detected, will retry! i=${i}`, {}, order_trace_id);
-                        if (errorMessage.includes('nonce too')) {
-                            const correctNonce = this.extractNonceFromErrorMsg(errorMessage);
-                            if (correctNonce !== null && correctNonce >= 0) {
-                                nonce_from_error = correctNonce;
-                            }
+                    if (errorMessage.includes('replacement transaction underpriced')) {
+                        (0, ttd_core_1.log_warn)(`Replacement tx underpriced, continue! i=${i}`, {}, order_trace_id);
+                        continue;
+                    }
+                    const isNonceError = errorMessage.includes('nonce');
+                    if (!isNonceError || i >= maxAttempts) {
+                        (0, ttd_core_1.log_warn)(`Non-nonce error or max retries, i=${i}, error: ${errorMessage}`, {}, order_trace_id);
+                        return txid;
+                    }
+                    (0, ttd_core_1.log_info)(`Nonce error detected, will retry! i=${i}`, {}, order_trace_id);
+                    if (errorMessage.includes('nonce too')) {
+                        const correctNonce = this.extractNonceFromErrorMsg(errorMessage);
+                        if (correctNonce !== null && correctNonce >= 0) {
+                            nonce_from_error = correctNonce;
                         }
                     }
-                } while (++i <= maxAttempts);
-                if (!txid) {
-                    throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
                 }
-                return txid;
-            }
-            finally {
-                yield callerHandle.release();
+            } while (++i <= maxAttempts);
+            if (!txid) {
+                throw new Error(`交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
             }
+            return txid;
         });
     }
     getGasPriceGwei(context) {

package/dist/trade/caller_manager.d.ts

@@ -2,16 +2,12 @@ import { ethers } from "ethers";
 export interface CallerHandle {
     wallet: ethers.Wallet;
     nonce: number;
-    release: () => Promise<void>;
 }
 export interface CallerManagerConfig {
     chainName: string;
     provider: ethers.providers.JsonRpcProvider;
     callerGroupIds: string[];
     chainId: number;
-    lockExpireSeconds?: number;
-    acquireTimeoutMs?: number;
-    acquireRetryIntervalMs?: number;
 }
 export declare class CallerManager {
     private callers;
@@ -26,10 +22,8 @@ export declare class CallerManager {
     getCallerAddresses(): string[];
     private getNonceRedisKey;
     private getLastUsedRedisKey;
-    private getLockKey;
     private getNonce;
     private setNonce;
-    private advanceNonce;
     private getCallersSortedByLRU;
     private updateLastUsed;
 }

package/dist/trade/caller_manager.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallerManager = void 0;
-const ttd_core_1 = require("@clonegod/ttd-core");
+const dist_1 = require("@clonegod/ttd-core/dist");
 const ethers_1 = require("ethers");
 const redis_1 = require("../redis");
 const CALLER_NONCE_KEY = 'caller:nonce';
@@ -19,29 +19,28 @@ const VAULT_CALLERS_KEY = 'vault:callers';
 class CallerManager {
     constructor(config) {
         this.callers = [];
-        this.config = Object.assign({ lockExpireSeconds: 3, acquireTimeoutMs: 2000, acquireRetryIntervalMs: 50 }, config);
+        this.config = config;
         this.redis = new redis_1.SimpleRedisClient(`${config.chainName}:caller`);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            const walletInfos = (0, ttd_core_1.load_wallet_multi)(this.config.callerGroupIds, false);
+            const walletInfos = (0, dist_1.load_wallet_multi)(this.config.callerGroupIds, false);
             const allWallets = walletInfos.map(info => new ethers_1.ethers.Wallet(info.private_key, this.config.provider));
-            (0, ttd_core_1.log_info)(`CallerManager: loaded ${allWallets.length} wallets from CALLER_GROUP_IDS`, allWallets.map(w => w.address));
+            (0, dist_1.log_info)(`CallerManager: loaded ${allWallets.length} wallets from CALLER_GROUP_IDS`, allWallets.map(w => w.address));
             const vaultCallersKey = `${this.config.chainName}:${VAULT_CALLERS_KEY}`;
             const allowedAddresses = yield this.redis.lrange(vaultCallersKey);
             if (allowedAddresses && allowedAddresses.length > 0) {
                 const allowedSet = new Set(allowedAddresses.map(a => a.toLowerCase()));
                 this.callers = allWallets.filter(w => allowedSet.has(w.address.toLowerCase()));
-                const matched = this.callers.map(w => w.address);
-                const skipped = allWallets.filter(w => !allowedSet.has(w.address.toLowerCase())).map(w => w.address);
-                (0, ttd_core_1.log_info)(`CallerManager: matched ${this.callers.length} callers with Vault whitelist`, matched);
+                (0, dist_1.log_info)(`CallerManager: matched ${this.callers.length} callers with Vault whitelist`, this.callers.map(w => w.address));
+                const skipped = allWallets.filter(w => !allowedSet.has(w.address.toLowerCase()));
                 if (skipped.length > 0) {
-                    (0, ttd_core_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped);
+                    (0, dist_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped.map(w => w.address));
                 }
             }
             else {
                 this.callers = allWallets;
-                (0, ttd_core_1.log_warn)(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey}), using all ${this.callers.length} loaded wallets`);
+                (0, dist_1.log_warn)(`CallerManager: Vault whitelist not found in Redis (${vaultCallersKey}), using all ${this.callers.length} loaded wallets`);
             }
             if (this.callers.length === 0) {
                 throw new Error('CallerManager: no valid callers after whitelist matching');
@@ -50,45 +49,25 @@ class CallerManager {
                 const address = caller.address.toLowerCase();
                 const nonceKey = this.getNonceRedisKey();
                 const existing = yield this.redis.hgetvalue(nonceKey, address);
-                if (existing !== null && existing !== undefined) {
-                    (0, ttd_core_1.log_info)(`Caller ${caller.address} nonce from Redis: ${existing}`);
-                    return;
+                if (existing === null || existing === undefined) {
+                    (0, dist_1.log_warn)(`Caller ${caller.address} nonce not found in Redis, stream-trade may not be running`);
+                }
+                else {
+                    (0, dist_1.log_info)(`Caller ${caller.address} nonce=${existing} (from Redis)`);
                 }
-                const nonce = yield this.config.provider.getTransactionCount(caller.address, 'pending');
-                yield this.redis.hsetValue(nonceKey, address, String(nonce), 24 * 60 * 60);
-                (0, ttd_core_1.log_info)(`Caller ${caller.address} nonce from chain: ${nonce}`);
             })));
-            (0, ttd_core_1.log_info)(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
+            (0, dist_1.log_info)(`CallerManager initialized, ${this.callers.length} active callers`, this.callers.map(w => w.address));
         });
     }
     acquireCaller() {
         return __awaiter(this, void 0, void 0, function* () {
             const startTime = Date.now();
-            const timeout = this.config.acquireTimeoutMs;
-            const retryInterval = this.config.acquireRetryIntervalMs;
-            while (Date.now() - startTime < timeout) {
-                const sortedCallers = yield this.getCallersSortedByLRU();
-                for (const caller of sortedCallers) {
-                    const lockKey = this.getLockKey(caller.address);
-                    const lockValue = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-                    const acquired = yield this.redis.acquireLock(lockKey, lockValue, this.config.lockExpireSeconds);
-                    if (!acquired)
-                        continue;
-                    const nonce = yield this.getNonce(caller.address);
-                    yield this.updateLastUsed(caller.address);
-                    (0, ttd_core_1.log_info)(`acquireCaller: ${caller.address}, nonce=${nonce}, took ${Date.now() - startTime}ms`);
-                    const address = caller.address;
-                    return {
-                        wallet: caller,
-                        nonce,
-                        release: () => __awaiter(this, void 0, void 0, function* () {
-                            yield this.redis.releaseLock(lockKey, lockValue);
-                        })
-                    };
-                }
-                yield (0, ttd_core_1.sleep)(retryInterval);
-            }
-            throw new Error(`acquireCaller failed: all ${this.callers.length} callers are busy, waited ${Date.now() - startTime}ms`);
+            const sortedCallers = yield this.getCallersSortedByLRU();
+            const caller = sortedCallers[0];
+            const nonce = yield this.getNonce(caller.address);
+            yield this.updateLastUsed(caller.address);
+            (0, dist_1.log_info)(`acquireCaller: ${caller.address}, nonce=${nonce}, took ${Date.now() - startTime}ms`);
+            return { wallet: caller, nonce };
         });
     }
     confirmNonce(address, confirmedNonce) {
@@ -96,7 +75,7 @@ class CallerManager {
             const current = yield this.getNonce(address);
             if (confirmedNonce > current) {
                 yield this.setNonce(address, confirmedNonce);
-                (0, ttd_core_1.log_info)(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
+                (0, dist_1.log_info)(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
             }
         });
     }
@@ -105,7 +84,7 @@ class CallerManager {
             const current = yield this.getNonce(address);
             if (nonce !== current) {
                 yield this.setNonce(address, nonce);
-                (0, ttd_core_1.log_info)(`forceSetNonce: ${address}, ${current} → ${nonce}`);
+                (0, dist_1.log_info)(`forceSetNonce: ${address}, ${current} → ${nonce}`);
             }
         });
     }
@@ -121,9 +100,6 @@ class CallerManager {
     getLastUsedRedisKey() {
         return `${this.config.chainName}:${CALLER_LAST_USED_KEY}`;
     }
-    getLockKey(address) {
-        return `${this.config.chainName}:lock:caller:${address.toLowerCase()}`;
-    }
     getNonce(address) {
         return __awaiter(this, void 0, void 0, function* () {
             const nonceKey = this.getNonceRedisKey();
@@ -140,14 +116,6 @@ class CallerManager {
             yield this.redis.hsetValue(nonceKey, address.toLowerCase(), String(nonce), 24 * 60 * 60);
         });
     }
-    advanceNonce(address, newNonce) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const current = yield this.getNonce(address);
-            if (newNonce > current) {
-                yield this.setNonce(address, newNonce);
-            }
-        });
-    }
     getCallersSortedByLRU() {
         return __awaiter(this, void 0, void 0, function* () {
             const lastUsedKey = this.getLastUsedRedisKey();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.0.10",
+  "version": "3.0.12",
   "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.5",
+    "@clonegod/ttd-core": "3.0.7",
     "@clonegod/ttd-bsc-send-tx": "1.0.0",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",