@clonegod/ttd-bsc-common 1.0.90 → 3.0.1

package/dist/trade/abstract_dex_trade.js

@@ -8,146 +8,251 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractEvmDexTrade = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+exports.AbstractDexTrade = void 0;
+exports.buildTradeConfig = buildTradeConfig;
+const ttd_core_1 = require("@clonegod/ttd-core");
 const ethers_1 = require("ethers");
-const common_1 = require("../common");
-class AbstractEvmDexTrade extends dist_1.AbastrcatTrade {
+const caller_manager_1 = require("./caller_manager");
+const ttd_bsc_send_tx_1 = require("@clonegod/ttd-bsc-send-tx");
+const redis_1 = require("../redis");
+const trade_direction_1 = require("../utils/trade_direction");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function buildTradeConfig() {
+    const vaultAddress = process.env.VAULT_ADDRESS;
+    if (!vaultAddress) {
+        throw new Error('环境变量 VAULT_ADDRESS 未配置');
+    }
+    const pancakeIdName = process.env.PANCAKE_EXECUTOR_ID || 'PANCAKE';
+    const uniswapIdName = process.env.UNISWAP_EXECUTOR_ID || 'UNISWAP';
+    return {
+        vaultAddress,
+        executorIds: {
+            pancake: ethers_1.ethers.utils.id(pancakeIdName),
+            uniswap: ethers_1.ethers.utils.id(uniswapIdName),
+        },
+    };
+}
+const VAULT_ABI = [
+    'function delegatecallExecutorToTrade(bytes32 executorId, bytes calldata data, uint256 deadline) external payable returns (bytes memory result)'
+];
+class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
     constructor(appConfig) {
         super();
         this.appConfig = appConfig;
-        this.approvedTokens = new Map();
-        this.pairContracts = new Map();
-        this.tokenContracts = new Map();
-        this.approvedTokens = new Map();
-        this.pairContracts = new Map();
-        this.tokenContracts = new Map();
         this.initConfigs();
+        this.chainNameLower = this.appConfig.env_args.chain_id.toLowerCase();
+        this.redisClient = new redis_1.SimpleRedisClient(`${this.chainNameLower}:tx`);
+        this.vaultInterface = new ethers_1.ethers.utils.Interface(VAULT_ABI);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
-            this.wallet = new ethers_1.ethers.Wallet(this.appConfig.trade_runtime.wallet.private_key, this.provider);
-            (0, dist_1.log_info)(`钱包已初始化，地址: ${this.wallet.address}`);
-            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.wallet);
-            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}`);
+            this.transactionSender = new ttd_bsc_send_tx_1.TransactionSender(this.appConfig);
+            const callerGroupIds = (process.env.CALLER_GROUP_IDS || '').trim().split(',').filter(Boolean);
+            this.callerManager = new caller_manager_1.CallerManager({
+                chainName: this.chainNameLower,
+                provider: this.provider,
+                callerGroupIds,
+                chainId: this.chainConfig.chainId,
+            });
+            yield this.callerManager.init();
+            this.subscribeTradeMonitor();
+            (0, ttd_core_1.log_info)(`AbstractDexTrade initialized, vault=${this.tradeConfig.vaultAddress}, callers=${this.callerManager.getCallerCount()}`);
         });
     }
-    getTokenContract(tokenAddress) {
-        if (!this.tokenContracts.has(tokenAddress)) {
-            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.wallet);
-            this.tokenContracts.set(tokenAddress, tokenContract);
+    execute(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { price_msg, order_msg, slippage_bps, order_trace_id, pool_info } = context;
+            const { pair } = price_msg;
+            const { aToB, amount, unique_order_msg_id } = order_msg;
+            (0, ttd_core_1.log_info)(`执行 Vault 交易, orderId=${order_trace_id}`, {
+                unique_order_msg_id,
+                pair,
+                aToB,
+                amount,
+                slippage_bps
+            });
+            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 = 0;
+                let txid = '';
+                let i = 1;
+                do {
+                    try {
+                        if (i > 1) {
+                            if (nonce_from_error > 0) {
+                                nonce = nonce_from_error;
+                                nonce_from_error = 0;
+                                (0, ttd_core_1.log_info)(`Attempt ${i}/${maxAttempts}, using nonce from error msg: ${nonce}`, {}, order_trace_id);
+                            }
+                            else {
+                                (0, ttd_core_1.log_warn)(`Attempt ${i}/${maxAttempts}, no nonce in error msg, abort`, {}, order_trace_id);
+                                break;
+                            }
+                        }
+                        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)(`Vault 交易已签名`, { txid, nonce, 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)(`Vault 交易发送成功`, {
+                            pair, unique_order_msg_id, 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;
+                        }
+                        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(`Vault 交易执行失败，已重试 ${maxAttempts} 次，orderId: ${order_trace_id}`);
+                }
+                return txid;
+            }
+            finally {
+                yield callerHandle.release();
+            }
+        });
+    }
+    subscribeTradeMonitor() {
+        const wsUrl = process.env.TRADE_MONITOR_WS_URL;
+        if (!wsUrl) {
+            (0, ttd_core_1.log_warn)('TRADE_MONITOR_WS_URL not configured, trade result nonce correction disabled');
+            return;
         }
-        return this.tokenContracts.get(tokenAddress);
+        const wsClient = new ttd_core_1.WebSocketClient(wsUrl);
+        wsClient.onOpen(() => {
+            wsClient.send(JSON.stringify({
+                vault_address: this.tradeConfig.vaultAddress,
+            }));
+            (0, ttd_core_1.log_info)(`Subscribed to trade-monitor for vault=${this.tradeConfig.vaultAddress}`);
+        });
+        wsClient.onMessage((event) => {
+            if (event.type === 'TradeResult' && event.data) {
+                const { caller, callerNonce } = event.data;
+                if (caller) {
+                    const nextNonce = callerNonce + 2;
+                    this.callerManager.confirmNonce(caller, nextNonce).catch(err => (0, ttd_core_1.log_warn)(`Failed to confirm nonce from trade-monitor`, err));
+                }
+            }
+        });
+        wsClient.connect();
     }
     getGasPriceGwei(context) {
-        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
-        if (evm_gas_price_gwei === undefined || evm_gas_price_gwei === null || evm_gas_price_gwei <= 0) {
+        let { evm_gas_price_gwei } = context.trade_runtime.settings.strategy;
+        if (!evm_gas_price_gwei || evm_gas_price_gwei <= 0) {
             evm_gas_price_gwei = this.chainConfig.gasOptions.defaultGasPriceGwei;
         }
-        (0, dist_1.log_info)(`getGasPriceGwei: ${evm_gas_price_gwei} Gwei`);
         return evm_gas_price_gwei.toString();
     }
     getBuilderTipAmoutGwei(context) {
-        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
-        if (evm_tip_amount_gwei === undefined || evm_tip_amount_gwei === null || evm_tip_amount_gwei <= 0) {
+        let { evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (!evm_tip_amount_gwei || evm_tip_amount_gwei <= 0) {
             evm_tip_amount_gwei = this.chainConfig.gasOptions.defaultTipAmountGwei;
         }
-        (0, dist_1.log_info)(`getGasTipAmoutGwei: ${evm_tip_amount_gwei} Gwei`);
         return evm_tip_amount_gwei.toString();
     }
-    checkTradeTokenApprove(context, routerAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { pool_info } = context;
-            const { tokenA, tokenB } = pool_info;
-            const router = routerAddress || this.dexConfig.routerAddress;
-            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
-                const tokenContract = this.getTokenContract(address);
-                yield this.checkTokenApprove(address, symbol, tokenContract, router);
-            })));
-        });
-    }
-    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.approvedTokens.get(tokenAddress)) {
-                (0, dist_1.log_info)(`代币 ${tokenSymbol} 已授权，跳过授权检查`);
-                return true;
-            }
-            const allowance = yield tokenContract.allowance(this.wallet.address, spenderAddress);
-            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
-            (0, dist_1.log_info)(`代币授权检查:`, {
-                tokenSymbol,
-                currentAllowance: allowance.toString(),
-                maxAllowance: maxAllowance.toString(),
-                isSufficient: allowance.gte(maxAllowance)
-            });
-            if (allowance.lt(maxAllowance)) {
-                const maxApprovalAmount = ethers_1.ethers.utils.formatUnits(ethers_1.ethers.constants.MaxUint256, yield tokenContract.decimals());
-                const tokenSymbolDisplay = tokenSymbol || `${tokenAddress.substring(0, 6)}...`;
-                (0, dist_1.log_info)(`正在为合约授权代币 ${tokenSymbolDisplay}`, {
-                    tokenAddress,
-                    tokenSymbol: tokenSymbolDisplay,
-                    currentAllowance: ethers_1.ethers.utils.formatUnits(allowance, yield tokenContract.decimals()),
-                    newAllowance: maxApprovalAmount
-                });
-                const tx = yield tokenContract.approve(spenderAddress, ethers_1.ethers.constants.MaxUint256, {
-                    gasLimit: this.chainConfig.gasOptions.gasLimit
-                });
-                yield tx.wait();
-                this.approvedTokens.set(tokenAddress, true);
-                (0, dist_1.log_info)(`代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
-                return true;
-            }
-            else {
-                this.approvedTokens.set(tokenAddress, true);
-                return true;
-            }
-        });
-    }
-    isNonceRelatedError(error) {
-        if (!error)
-            return false;
-        const errorMessage = error.message ? error.message.toLowerCase() : '';
-        const nonceErrorKeywords = [
-            'nonce',
-            'nonce too low',
-            'nonce too high',
-            'nonce has already been used',
-            'already known',
-            'replacement transaction underpriced',
-            'transaction with same nonce',
-            'transaction nonce is too low',
-            'invalid transaction nonce',
-            'insufficient funds',
-            'sign bundle to get failure details',
-        ];
-        return nonceErrorKeywords.some(keyword => errorMessage.includes(keyword));
-    }
-    isNativeCurrency(symbol) {
-        return symbol.toUpperCase() === this.chainConfig.nativeCurrency;
-    }
-    getWrappedNativeAddress() {
-        return this.chainConfig.wrappedNativeCurrencyAddress;
-    }
-    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, transfer_nonce) {
+    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, nonce, wallet) {
         return __awaiter(this, void 0, void 0, function* () {
-            let real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
-            let real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
-            let tx_data = {
-                from: this.wallet.address,
+            const real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
+            const real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+            const tx_data = {
+                from: wallet.address,
                 to,
                 value: ethers_1.ethers.utils.parseUnits(real_transfer_amount_gwei, 'gwei'),
-                gasLimit: 21000,
+                gasLimit: 42000,
                 gasPrice: ethers_1.ethers.utils.parseUnits(real_gas_price_gwei, 'gwei'),
-                nonce: transfer_nonce,
+                nonce,
                 chainId: this.chainConfig.chainId
             };
-            let signedTx = yield this.wallet.signTransaction(tx_data);
-            (0, dist_1.log_info)(`构建转账交易: `, Object.assign(Object.assign({}, tx_data), { real_transfer_amount_gwei,
-                real_gas_price_gwei, txhash: ethers_1.ethers.utils.keccak256(signedTx) }));
+            const signedTx = yield wallet.signTransaction(tx_data);
+            (0, ttd_core_1.log_info)(`构建 tip 转账交易`, {
+                to, nonce,
+                tipGwei: real_transfer_amount_gwei,
+                txhash: ethers_1.ethers.utils.keccak256(signedTx)
+            });
             return signedTx;
         });
     }
+    determineInputOutputTokens(order_msg, pool_info) {
+        const { inputToken, outputToken } = (0, trade_direction_1.resolveTradeDirection)(pool_info, order_msg.isBuy);
+        return { inputToken, outputToken };
+    }
+    calculateAmountOutMin(context, inputToken, outputToken) {
+        const { price_msg, slippage_bps, order_msg } = context;
+        const { isBuy } = order_msg;
+        const slippage = slippage_bps / 10000;
+        const inputAmount = new decimal_js_1.default(order_msg.amount.toString());
+        let expectedOut;
+        if (isBuy) {
+            const price = new decimal_js_1.default(price_msg.ask.price);
+            expectedOut = inputAmount.div(price);
+        }
+        else {
+            const price = new decimal_js_1.default(price_msg.bid.price);
+            expectedOut = inputAmount.mul(price);
+        }
+        const minOutput = expectedOut.mul(new decimal_js_1.default(1).sub(new decimal_js_1.default(slippage)));
+        return ethers_1.ethers.utils.parseUnits(minOutput.toFixed(outputToken.decimals), outputToken.decimals);
+    }
+    extractNonceFromErrorMsg(errorMessage) {
+        try {
+            const match = errorMessage.match(/tx:\s*(\d+)\s*state:\s*(\d+)/);
+            if (match) {
+                return parseInt(match[2]);
+            }
+        }
+        catch (_a) { }
+        return null;
+    }
 }
-exports.AbstractEvmDexTrade = AbstractEvmDexTrade;
+exports.AbstractDexTrade = AbstractDexTrade;

package/dist/trade/caller_manager.d.ts

@@ -0,0 +1,35 @@
+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;
+    private redis;
+    private config;
+    constructor(config: CallerManagerConfig);
+    init(): Promise<void>;
+    acquireCaller(): Promise<CallerHandle>;
+    confirmNonce(address: string, confirmedNonce: number): Promise<void>;
+    forceSetNonce(address: string, nonce: number): Promise<void>;
+    getCallerCount(): number;
+    getCallerAddresses(): string[];
+    private getNonceRedisKey;
+    private getLastUsedRedisKey;
+    private getLockKey;
+    private getNonce;
+    private setNonce;
+    private advanceNonce;
+    private getCallersSortedByLRU;
+    private updateLastUsed;
+}

package/dist/trade/caller_manager.js

@@ -0,0 +1,178 @@
+"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.CallerManager = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const ethers_1 = require("ethers");
+const redis_1 = require("../redis");
+const CALLER_NONCE_KEY = 'caller:nonce';
+const CALLER_LAST_USED_KEY = 'caller:last_used';
+const VAULT_CALLERS_KEY = 'vault:callers';
+class CallerManager {
+    constructor(config) {
+        this.callers = [];
+        this.config = Object.assign({ lockExpireSeconds: 3, acquireTimeoutMs: 2000, acquireRetryIntervalMs: 50 }, 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 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));
+            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);
+                if (skipped.length > 0) {
+                    (0, ttd_core_1.log_warn)(`CallerManager: skipped ${skipped.length} wallets not in Vault whitelist`, skipped);
+                }
+            }
+            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`);
+            }
+            if (this.callers.length === 0) {
+                throw new Error('CallerManager: no valid callers after whitelist matching');
+            }
+            yield Promise.all(this.callers.map((caller) => __awaiter(this, void 0, void 0, function* () {
+                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;
+                }
+                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));
+        });
+    }
+    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.advanceNonce(address, nonce + 2);
+                            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`);
+        });
+    }
+    confirmNonce(address, confirmedNonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const current = yield this.getNonce(address);
+            if (confirmedNonce > current) {
+                yield this.setNonce(address, confirmedNonce);
+                (0, ttd_core_1.log_info)(`confirmNonce: ${address}, ${current} → ${confirmedNonce}`);
+            }
+        });
+    }
+    forceSetNonce(address, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const current = yield this.getNonce(address);
+            if (nonce !== current) {
+                yield this.setNonce(address, nonce);
+                (0, ttd_core_1.log_info)(`forceSetNonce: ${address}, ${current} → ${nonce}`);
+            }
+        });
+    }
+    getCallerCount() {
+        return this.callers.length;
+    }
+    getCallerAddresses() {
+        return this.callers.map(w => w.address);
+    }
+    getNonceRedisKey() {
+        return `${this.config.chainName}:${CALLER_NONCE_KEY}`;
+    }
+    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();
+            const val = yield this.redis.hgetvalue(nonceKey, address.toLowerCase());
+            if (val !== null && val !== undefined) {
+                return parseInt(val, 10);
+            }
+            throw new Error(`Caller ${address} nonce not found in Redis, init() may not have been called`);
+        });
+    }
+    setNonce(address, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonceKey = this.getNonceRedisKey();
+            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();
+            const lastUsedData = yield this.redis.hgetall(lastUsedKey);
+            const callersWithTime = this.callers.map(caller => {
+                let lastUsedAt = 0;
+                const data = lastUsedData === null || lastUsedData === void 0 ? void 0 : lastUsedData[caller.address.toLowerCase()];
+                if (data) {
+                    try {
+                        lastUsedAt = parseInt(data, 10) || 0;
+                    }
+                    catch (_a) { }
+                }
+                return { caller, lastUsedAt };
+            });
+            callersWithTime.sort((a, b) => a.lastUsedAt - b.lastUsedAt);
+            return callersWithTime.map(item => item.caller);
+        });
+    }
+    updateLastUsed(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lastUsedKey = this.getLastUsedRedisKey();
+            yield this.redis.hsetValue(lastUsedKey, address.toLowerCase(), String(Date.now()), 24 * 60 * 60);
+        });
+    }
+}
+exports.CallerManager = CallerManager;

package/dist/trade/check/tx_websocket_manager.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketManager = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class WebSocketManager {
     constructor() {
         this.wsProvider = null;
@@ -50,32 +50,32 @@ class WebSocketManager {
     getWsProvider(wsEndpoint, network) {
         var _a;
         if (!wsEndpoint) {
-            (0, dist_1.log_warn)('WebSocket endpoint not configured');
+            (0, ttd_core_1.log_warn)('WebSocket endpoint not configured');
             return null;
         }
         if (!this.wsProvider) {
-            (0, dist_1.log_info)('Creating new WebSocket provider');
+            (0, ttd_core_1.log_info)('Creating new WebSocket provider');
             try {
                 this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(wsEndpoint, network);
                 this.wsProvider.on('error', (error) => {
-                    (0, dist_1.log_error)('[WS] provider error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
+                    (0, ttd_core_1.log_error)('[WS] provider error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
                     this.handleWsDisconnection(wsEndpoint, network);
                 });
                 const rawWs = (_a = this.wsProvider) === null || _a === void 0 ? void 0 : _a._websocket;
                 if (rawWs === null || rawWs === void 0 ? void 0 : rawWs.on) {
                     rawWs.on('close', (code, reason) => {
                         const reasonText = this.normalizeReason(reason);
-                        (0, dist_1.log_warn)('[WS] socket close', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), { code, reason: reasonText }));
+                        (0, ttd_core_1.log_warn)('[WS] socket close', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), { code, reason: reasonText }));
                         this.handleWsDisconnection(wsEndpoint, network);
                     });
                     rawWs.on('error', (err) => {
-                        (0, dist_1.log_error)('[WS] socket error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(err)));
+                        (0, ttd_core_1.log_error)('[WS] socket error', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(err)));
                         this.handleWsDisconnection(wsEndpoint, network);
                     });
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)('[WS] create provider failed', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
+                (0, ttd_core_1.log_error)('[WS] create provider failed', Object.assign(Object.assign({}, this.formatConn(wsEndpoint, network)), this.formatErr(error)));
                 this.wsProvider = null;
             }
         }
@@ -97,16 +97,16 @@ class WebSocketManager {
     }
     incrementConnections() {
         this.wsConnections++;
-        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        (0, ttd_core_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
     }
     decrementConnections() {
         var _a, _b, _c, _d;
         if (this.wsConnections > 0) {
             this.wsConnections--;
         }
-        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        (0, ttd_core_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
         if (this.wsConnections === 0 && this.wsProvider) {
-            (0, dist_1.log_info)('No active connections, closing WebSocket');
+            (0, ttd_core_1.log_info)('No active connections, closing WebSocket');
             try {
                 this.wsProvider.removeAllListeners();
                 const rawWs = (_a = this.wsProvider) === null || _a === void 0 ? void 0 : _a._websocket;
@@ -119,7 +119,7 @@ class WebSocketManager {
     }
     listenToEvent(eventName, handler) {
         if (!this.wsProvider) {
-            (0, dist_1.log_warn)('WebSocket provider not available for event listener');
+            (0, ttd_core_1.log_warn)('WebSocket provider not available for event listener');
             return;
         }
         if (!this.eventListeners.has(eventName)) {

package/dist/trade/index.d.ts

@@ -1,5 +1,4 @@
-export * from './send';
 export * from './parse';
 export * from './check';
+export * from './caller_manager';
 export * from './abstract_dex_trade';
-export * from './abstract_dex_trade_plus';