@clonegod/ttd-bsc-common 3.1.18 → 3.1.21

package/dist/config/BscQuoteAppConfig.js

@@ -9,6 +9,7 @@ class BscQuoteAppConfig extends ttd_core_1.AppConfig {
         super();
         this.eventEmitter = new events_1.EventEmitter();
         this.env_args = new bsc_env_args_1.BscEnvArgs();
+        (0, ttd_core_1.setCoreEnv)(this.env_args);
     }
     on(eventName, listener) {
         this.eventEmitter.on(eventName, listener);
@@ -36,6 +37,7 @@ class BscQuoteAppConfig extends ttd_core_1.AppConfig {
             (0, ttd_core_1.log_info)('Config change received', config);
             if (config.env_args) {
                 this.env_args = new bsc_env_args_1.BscEnvArgs();
+                (0, ttd_core_1.setCoreEnv)(this.env_args);
             }
             if (config.arb_cache) {
                 await this.arb_cache.init();

package/dist/config/bsc_env_args.d.ts

@@ -3,10 +3,69 @@ export declare class BscEnvArgs extends EnvArgs {
     gas_price_gwei: number;
     gas_limit: number;
     tip_amount_gwei: number;
+    pancake_executor_id: string;
+    uniswap_executor_id: string;
+    caller_select_strategy: string;
     send_tx_blockrazor_bundle: boolean;
     send_tx_48club_bundle: boolean;
     send_tx_48club_bundle_ws: boolean;
     send_tx_blox_bundle_ws: boolean;
+    stream_quote_ws_host: string;
+    min_quote_interval_ms: number;
+    skip_price_feed_yynode: boolean;
+    push_price_feed: boolean;
+    trade_parse_fetch_block_time: boolean;
+    tick_cache_neighboring_words: number;
+    tick_cache_ttl: number;
+    tick_cache_min_update_interval: number;
+    ws_push_enable: boolean;
+    print_event_data: boolean;
+    pool_sync_interval_ms: number;
+    redis_sync_pool_enable: boolean;
+    redis_url: string;
+    skip_pool_list: string;
+    price_feed_skip_dup: boolean;
+    trade_analyze_port: number;
+    log_max_size_mb: number;
+    log_check_interval_min: number;
+    log_dir: string;
+    chain_name: string;
+    caller_balance_check_interval: string;
+    caller_balance_low_threshold: string;
+    caller_balance_empty_threshold: string;
+    send_tx_ws_host: string;
+    send_tx_48club_ws: boolean;
+    send_tx_bloxroute_ws: boolean;
+    send_tx_default_rpc: boolean;
+    send_tx_blockrazor_private: boolean;
+    send_tx_48club_private: boolean;
+    bsc_rpc_endpoint: string;
+    bloxroute_ws_url: string;
+    blox_auth_key: string;
+    _48club_ws_url: string;
+    _48club_rpc_url: string;
+    _48club_sp_wallet_id: string;
+    blockrazor_rpc_url: string;
+    blockrazor_auth_token: string;
+    gecko_network: string;
+    chain_id_num: number;
+    native_token_symbol: string;
+    native_token_address: string;
+    wrapped_native_address: string;
+    sync_pool_interval_ms: number;
+    fetch_api_wait_ms: number;
+    fetch_min_tvl: number;
+    fetch_min_vol: number;
+    pool_default_tvl: number;
+    fetch_max_page_no: number;
+    token_batch_size: number;
+    fetch_on_startup: boolean;
+    vault_mgt_rpc_url: string;
+    vault_mgt_chain_id: number;
+    vault_mgt_chain_name: string;
+    vault_mgt_vault_groups: string;
+    vault_mgt_native_symbol: string;
+    vault_mgt_wrapped_native_address: string;
+    vault_mgt_fund_caller_max: string;
     constructor();
-    print(moduleName?: string): void;
 }

package/dist/config/bsc_env_args.js

@@ -2,19 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscEnvArgs = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
-const BSC_KEYS = [
-    'gas_price_gwei',
-    'gas_limit',
-    'tip_amount_gwei',
-    'send_tx_blockrazor_bundle',
-    'send_tx_48club_bundle',
-    'send_tx_48club_bundle_ws',
-    'send_tx_blox_bundle_ws',
-];
+const constants_1 = require("../common/constants");
 (0, ttd_core_1.registerEnvVars)({
     gas_price_gwei: { env: 'GAS_PRICE_GWEI', type: 'number', default: 1, desc: '交易 gas 价格(Gwei)' },
     gas_limit: { env: 'GAS_LIMIT', type: 'number', default: 300000, desc: '交易 gas 上限' },
     tip_amount_gwei: { env: 'TIP_AMOUNT_GWEI', type: 'number', default: 10000, desc: 'Builder tip(Gwei)' },
+    pancake_executor_id: { env: 'PANCAKE_EXECUTOR_ID', type: 'string', default: 'PANCAKE', desc: 'Vault 中 Pancake executor 注册名（keccak256 后作为 bytes32）' },
+    uniswap_executor_id: { env: 'UNISWAP_EXECUTOR_ID', type: 'string', default: 'UNISWAP', desc: 'Vault 中 Uniswap executor 注册名（keccak256 后作为 bytes32）' },
+    caller_select_strategy: { env: 'CALLER_SELECT_STRATEGY', type: 'string', default: 'lock', desc: 'CallerManager LRU 选择策略：lock=Redis 分布式锁(默认) | lua_cas=Lua 原子脚本(单 RTT，无锁重试)' },
     send_tx_blockrazor_bundle: { env: 'SEND_TX_BLOCKRAZOR_BUNDLE', type: 'boolean', default: false, desc: 'BlockRazor Bundle 开关' },
     send_tx_48club_bundle: { env: 'SEND_TX_48CLUB_BUNDLE', type: 'boolean', default: false, desc: '48Club Bundle HTTP 开关' },
     send_tx_48club_bundle_ws: { env: 'SEND_TX_48CLUB_BUNDLE_WS', type: 'boolean', default: false, desc: '48Club Bundle WS 开关' },
@@ -23,25 +18,130 @@ const BSC_KEYS = [
     min_quote_interval_ms: { env: 'MIN_QUOTE_INTERVAL_MS', type: 'number', default: 10000, desc: '最小询价间隔(ms)' },
     skip_price_feed_yynode: { env: 'SKIP_PRICE_FEED_YYNODE', type: 'boolean', default: false, desc: '跳过 YYNode PriceFeed' },
     push_price_feed: { env: 'PUSH_PRICE_FEED', type: 'boolean', default: false, desc: 'PriceFeed 推送开关' },
-    need_block_time_info: { env: 'NEED_BLOCK_TIME_INFO', type: 'boolean', default: false, desc: '区块时间信息开关' },
+    trade_parse_fetch_block_time: { env: 'TRADE_PARSE_FETCH_BLOCK_TIME', type: 'boolean', default: false, desc: '解析交易 receipt 时是否额外 RPC 查询 block 时间戳填入结果' },
     tick_cache_neighboring_words: { env: 'TICK_CACHE_NEIGHBORING_WORDS', type: 'number', default: 2, desc: 'tick 预加载 words 数' },
     tick_cache_ttl: { env: 'TICK_CACHE_TTL', type: 'number', default: 30000, desc: 'tick 缓存 TTL(ms)' },
     tick_cache_min_update_interval: { env: 'TICK_CACHE_MIN_UPDATE_INTERVAL', type: 'number', default: 3000, desc: 'tick 最小刷新间隔(ms)' },
+    ws_push_enable: { env: 'WS_PUSH_ENABLE', type: 'boolean', default: true, desc: 'WS 推送开关' },
+    print_event_data: { env: 'PRINT_EVENT_DATA', type: 'boolean', default: false, desc: '打印原始事件数据' },
+    pool_sync_interval_ms: { env: 'POOL_SYNC_INTERVAL_MS', type: 'number', default: 5000, desc: '池子同步间隔(ms)' },
+    redis_sync_pool_enable: { env: 'REDIS_SYNC_POOL_ENABLE', type: 'boolean', default: false, desc: 'Redis 同步池子开关' },
+    redis_url: { env: 'REDIS_URL', type: 'string', default: 'redis://127.0.0.1:6379', desc: 'Redis 连接 URL' },
+    skip_pool_list: { env: 'SKIP_POOL_LIST', type: 'string', default: '', desc: '跳过的池子名称列表(逗号分隔)' },
+    price_feed_skip_dup: { env: 'PRICE_FEED_SKIP_DUP', type: 'boolean', default: false, desc: 'PriceFeed 去重过滤' },
+    trade_analyze_port: { env: 'TRADE_ANALYZE_PORT', type: 'number', default: 8004, desc: '上报 analyze 的 HTTP 端口' },
+    log_max_size_mb: { env: 'LOG_MAX_SIZE_MB', type: 'number', default: 20, desc: '日志文件大小上限(MB)' },
+    log_check_interval_min: { env: 'LOG_CHECK_INTERVAL_MIN', type: 'number', default: 10, desc: '日志检查间隔(分钟)' },
+    log_dir: { env: 'LOG_DIR', type: 'string', default: 'logs', desc: '日志目录' },
+    chain_name: { env: 'CHAIN_NAME', type: 'string', default: '', desc: '链名称（Redis key 前缀），stream-trade 建议必填' },
+    caller_balance_check_interval: { env: 'CALLER_BALANCE_CHECK_INTERVAL', type: 'string', default: '1h', desc: 'caller 余额检查周期，支持 8h/30m/45s/100ms 格式' },
+    caller_balance_low_threshold: { env: 'CALLER_BALANCE_LOW_THRESHOLD', type: 'string', default: '0.01', desc: 'caller 低余额阈值（原生币单位），低于报 ERROR' },
+    caller_balance_empty_threshold: { env: 'CALLER_BALANCE_EMPTY_THRESHOLD', type: 'string', default: '0', desc: 'caller 耗尽阈值，低于报 CRITICAL；为 0 表示禁用此级' },
+    send_tx_ws_host: { env: 'SEND_TX_WS_HOST', type: 'string', default: '127.0.0.1', desc: 'send-tx WS 地址' },
+    send_tx_48club_ws: { env: 'SEND_TX_48CLUB_WS', type: 'boolean', default: false, desc: '48Club WS server 开关' },
+    send_tx_bloxroute_ws: { env: 'SEND_TX_BLOXROUTE_WS', type: 'boolean', default: false, desc: 'BloxRoute WS server 开关' },
+    send_tx_default_rpc: { env: 'SEND_TX_DEFAULT_RPC', type: 'boolean', default: false, desc: '默认 RPC 私有发送' },
+    send_tx_blockrazor_private: { env: 'SEND_TX_BLOCKRAZOR_PRIVATE', type: 'boolean', default: false, desc: 'BlockRazor 私有发送' },
+    send_tx_48club_private: { env: 'SEND_TX_48CLUB_PRIVATE', type: 'boolean', default: false, desc: '48Club 私有发送' },
+    bsc_rpc_endpoint: { env: 'BSC_RPC_ENDPOINT', type: 'string', default: '', desc: 'BSC RPC 端点（default_rpc 发送用）' },
+    bloxroute_ws_url: { env: 'BLOXROUTE_WS_URL', type: 'string', default: 'wss://api.blxrbdn.com/ws', desc: 'BloxRoute WS URL' },
+    blox_auth_key: { env: 'BLOX_AUTH_KEY', type: 'string', default: '', sensitive: true, desc: 'BloxRoute 认证 key' },
+    _48club_ws_url: { env: '_48CLUB_WS_URL', type: 'string', default: 'wss://puissant-builder.48.club/', desc: '48Club WS URL' },
+    _48club_rpc_url: { env: '_48CLUB_RPC_URL', type: 'string', default: 'https://puissant-builder.48.club/', desc: '48Club RPC URL' },
+    _48club_sp_wallet_id: { env: '_48CLUB_SP_WALLET_ID', type: 'string', default: 'TTD-PAYMENT', desc: '48Club SoulPoint 钱包 ID' },
+    blockrazor_rpc_url: { env: 'BLOCKRAZOR_RPC_URL', type: 'string', default: 'https://rpc.blockrazor.builders', desc: 'BlockRazor RPC URL' },
+    blockrazor_auth_token: { env: 'BLOCKRAZOR_AUTH_TOKEN', type: 'string', default: '', sensitive: true, desc: 'BlockRazor 认证 Token' },
+    gecko_network: { env: 'GECKO_NETWORK', type: 'string', default: '', desc: 'GeckoTerminal 网络标识（可选；缺省按 chain_id 推断）' },
+    chain_id_num: { env: 'CHAIN_ID_NUM', type: 'number', default: 56, desc: '链 ID 数字' },
+    native_token_symbol: { env: 'NATIVE_TOKEN_SYMBOL', type: 'string', default: 'BNB', desc: '原生代币符号' },
+    native_token_address: { env: 'NATIVE_TOKEN_ADDRESS', type: 'string', default: constants_1.NATIVE_BNB_ADDRESS, desc: '原生代币地址' },
+    wrapped_native_address: { env: 'WRAPPED_NATIVE_ADDRESS', type: 'string', default: constants_1.WBNB_ADDRESS, desc: 'Wrapped 代币地址' },
+    sync_pool_interval_ms: { env: 'SYNC_POOL_INTERVAL_MS', type: 'number', default: 3600000, desc: '定时池子全量同步间隔（毫秒）' },
+    fetch_api_wait_ms: { env: 'FETCH_API_WAIT_MS', type: 'number', default: 6000, desc: 'Gecko/DefiLlama 等外部 API 调用间隔（毫秒）' },
+    fetch_min_tvl: { env: 'FETCH_MIN_TVL', type: 'number', default: 50000, desc: '最小 TVL(USD)' },
+    fetch_min_vol: { env: 'FETCH_MIN_VOL', type: 'number', default: 100000, desc: '最小 24h 成交量(USD)' },
+    pool_default_tvl: { env: 'POOL_DEFAULT_TVL', type: 'number', default: 100000, desc: '默认 TVL' },
+    fetch_max_page_no: { env: 'FETCH_MAX_PAGE_NO', type: 'number', default: 10, desc: '最大翻页数' },
+    token_batch_size: { env: 'TOKEN_BATCH_SIZE', type: 'number', default: 10, desc: 'token 批量大小' },
+    fetch_on_startup: { env: 'FETCH_ON_STARTUP', type: 'boolean', default: true, desc: '启动时立即执行' },
+    vault_mgt_rpc_url: { env: 'VAULT_MGT_RPC_URL', type: 'string', default: '', desc: 'Vault 管理 RPC（contract-mgt 必填）' },
+    vault_mgt_chain_id: { env: 'VAULT_MGT_CHAIN_ID', type: 'number', default: 0, desc: '链 ID 数字（contract-mgt 必填）' },
+    vault_mgt_chain_name: { env: 'VAULT_MGT_CHAIN_NAME', type: 'string', default: '', desc: '链名称（contract-mgt 必填）' },
+    vault_mgt_vault_groups: { env: 'VAULT_MGT_VAULT_GROUPS', type: 'string', default: '', desc: 'Vault 分组列表(逗号分隔，contract-mgt 必填)' },
+    vault_mgt_native_symbol: { env: 'VAULT_MGT_NATIVE_SYMBOL', type: 'string', default: '', desc: '原生代币符号（contract-mgt 必填）' },
+    vault_mgt_wrapped_native_address: { env: 'VAULT_MGT_WRAPPED_NATIVE_ADDRESS', type: 'string', default: '', desc: 'Wrapped 代币地址（contract-mgt 必填）' },
+    vault_mgt_fund_caller_max: { env: 'VAULT_MGT_FUND_CALLER_MAX', type: 'string', default: '', desc: 'Caller 充值上限' },
 });
 class BscEnvArgs extends ttd_core_1.EnvArgs {
     constructor() {
         super();
-        const cfg = (0, ttd_core_1.loadEnvConfig)(BSC_KEYS);
-        this.gas_price_gwei = cfg.gas_price_gwei;
-        this.gas_limit = cfg.gas_limit;
-        this.tip_amount_gwei = cfg.tip_amount_gwei;
-        this.send_tx_blockrazor_bundle = cfg.send_tx_blockrazor_bundle;
-        this.send_tx_48club_bundle = cfg.send_tx_48club_bundle;
-        this.send_tx_48club_bundle_ws = cfg.send_tx_48club_bundle_ws;
-        this.send_tx_blox_bundle_ws = cfg.send_tx_blox_bundle_ws;
-    }
-    print(moduleName) {
-        super.print(moduleName);
+        this.gas_price_gwei = this._cfg.gas_price_gwei;
+        this.gas_limit = this._cfg.gas_limit;
+        this.tip_amount_gwei = this._cfg.tip_amount_gwei;
+        this.pancake_executor_id = this._cfg.pancake_executor_id;
+        this.uniswap_executor_id = this._cfg.uniswap_executor_id;
+        this.caller_select_strategy = this._cfg.caller_select_strategy;
+        this.send_tx_blockrazor_bundle = this._cfg.send_tx_blockrazor_bundle;
+        this.send_tx_48club_bundle = this._cfg.send_tx_48club_bundle;
+        this.send_tx_48club_bundle_ws = this._cfg.send_tx_48club_bundle_ws;
+        this.send_tx_blox_bundle_ws = this._cfg.send_tx_blox_bundle_ws;
+        this.stream_quote_ws_host = this._cfg.stream_quote_ws_host;
+        this.min_quote_interval_ms = this._cfg.min_quote_interval_ms;
+        this.skip_price_feed_yynode = this._cfg.skip_price_feed_yynode;
+        this.push_price_feed = this._cfg.push_price_feed;
+        this.trade_parse_fetch_block_time = this._cfg.trade_parse_fetch_block_time;
+        this.tick_cache_neighboring_words = this._cfg.tick_cache_neighboring_words;
+        this.tick_cache_ttl = this._cfg.tick_cache_ttl;
+        this.tick_cache_min_update_interval = this._cfg.tick_cache_min_update_interval;
+        this.ws_push_enable = this._cfg.ws_push_enable;
+        this.print_event_data = this._cfg.print_event_data;
+        this.pool_sync_interval_ms = this._cfg.pool_sync_interval_ms;
+        this.redis_sync_pool_enable = this._cfg.redis_sync_pool_enable;
+        this.redis_url = this._cfg.redis_url;
+        this.skip_pool_list = this._cfg.skip_pool_list;
+        this.price_feed_skip_dup = this._cfg.price_feed_skip_dup;
+        this.trade_analyze_port = this._cfg.trade_analyze_port;
+        this.log_max_size_mb = this._cfg.log_max_size_mb;
+        this.log_check_interval_min = this._cfg.log_check_interval_min;
+        this.log_dir = this._cfg.log_dir;
+        this.chain_name = this._cfg.chain_name;
+        this.caller_balance_check_interval = this._cfg.caller_balance_check_interval;
+        this.caller_balance_low_threshold = this._cfg.caller_balance_low_threshold;
+        this.caller_balance_empty_threshold = this._cfg.caller_balance_empty_threshold;
+        this.send_tx_ws_host = this._cfg.send_tx_ws_host;
+        this.send_tx_48club_ws = this._cfg.send_tx_48club_ws;
+        this.send_tx_bloxroute_ws = this._cfg.send_tx_bloxroute_ws;
+        this.send_tx_default_rpc = this._cfg.send_tx_default_rpc;
+        this.send_tx_blockrazor_private = this._cfg.send_tx_blockrazor_private;
+        this.send_tx_48club_private = this._cfg.send_tx_48club_private;
+        this.bsc_rpc_endpoint = this._cfg.bsc_rpc_endpoint;
+        this.bloxroute_ws_url = this._cfg.bloxroute_ws_url;
+        this.blox_auth_key = this._cfg.blox_auth_key;
+        this._48club_ws_url = this._cfg._48club_ws_url;
+        this._48club_rpc_url = this._cfg._48club_rpc_url;
+        this._48club_sp_wallet_id = this._cfg._48club_sp_wallet_id;
+        this.blockrazor_rpc_url = this._cfg.blockrazor_rpc_url;
+        this.blockrazor_auth_token = this._cfg.blockrazor_auth_token;
+        this.gecko_network = (this._cfg.gecko_network || this.chain_id || 'bsc').toLowerCase();
+        this.chain_id_num = this._cfg.chain_id_num;
+        this.native_token_symbol = this._cfg.native_token_symbol;
+        this.native_token_address = this._cfg.native_token_address;
+        this.wrapped_native_address = this._cfg.wrapped_native_address;
+        this.sync_pool_interval_ms = this._cfg.sync_pool_interval_ms;
+        this.fetch_api_wait_ms = this._cfg.fetch_api_wait_ms;
+        this.fetch_min_tvl = this._cfg.fetch_min_tvl;
+        this.fetch_min_vol = this._cfg.fetch_min_vol;
+        this.pool_default_tvl = this._cfg.pool_default_tvl;
+        this.fetch_max_page_no = this._cfg.fetch_max_page_no;
+        this.token_batch_size = this._cfg.token_batch_size;
+        this.fetch_on_startup = this._cfg.fetch_on_startup;
+        this.vault_mgt_rpc_url = this._cfg.vault_mgt_rpc_url;
+        this.vault_mgt_chain_id = this._cfg.vault_mgt_chain_id;
+        this.vault_mgt_chain_name = this._cfg.vault_mgt_chain_name;
+        this.vault_mgt_vault_groups = this._cfg.vault_mgt_vault_groups;
+        this.vault_mgt_native_symbol = this._cfg.vault_mgt_native_symbol;
+        this.vault_mgt_wrapped_native_address = this._cfg.vault_mgt_wrapped_native_address;
+        this.vault_mgt_fund_caller_max = this._cfg.vault_mgt_fund_caller_max;
     }
 }
 exports.BscEnvArgs = BscEnvArgs;

package/dist/quote/verify/quote_price_verify.js

@@ -141,7 +141,7 @@ class QuotePriceVerify {
         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}`;
         (0, ttd_core_1.log_info)(msg);
         try {
-            (0, ttd_core_1.report_trade_analyze_data)('QuoteVerify', {
+            (0, ttd_core_1.report_data_to_analyze)('QuoteVerify', {
                 pool_address: poolAddress,
                 pool_name: poolName,
                 price_id: cached.priceId,

package/dist/trade/abstract_dex_trade.d.ts

@@ -1,4 +1,5 @@
 import { AbastrcatTrade, AppConfig, TradeContext } from '@clonegod/ttd-core';
+import { BscEnvArgs } from '../config/bsc_env_args';
 import { ethers } from "ethers";
 import { EvmChainConfig } from "../types";
 import { CallerManager } from "./caller_manager";
@@ -8,7 +9,7 @@ export interface TradeConfig {
     vaultAddress: string;
     executorIds: Record<string, string>;
 }
-export declare function buildTradeConfig(): TradeConfig;
+export declare function buildTradeConfig(envArgs: BscEnvArgs): TradeConfig;
 export interface TradeCalldata {
     executorId: string;
     data: string;

package/dist/trade/abstract_dex_trade.js

@@ -45,29 +45,27 @@ const path = __importStar(require("path"));
 const constants_1 = require("../common/constants");
 const caller_manager_1 = require("./caller_manager");
 const send_tx_1 = require("../send-tx");
-const base_tx_result_checker_1 = require("./check/base_tx_result_checker");
+const abstract_tx_result_checker_1 = require("./check/abstract_tx_result_checker");
 const ttd_core_2 = require("@clonegod/ttd-core");
 const trade_direction_1 = require("../utils/trade_direction");
 const ethers_compat_1 = require("../utils/ethers_compat");
 const fast_signer_1 = require("../utils/fast_signer");
 const trade_trace_1 = require("./trade_trace");
 const decimal_js_1 = __importDefault(require("decimal.js"));
-function buildTradeConfig() {
-    const vaultGroupId = process.env.TRADE_GROUP_ID || process.env.VAULT_GROUP_ID;
+function buildTradeConfig(envArgs) {
+    const vaultGroupId = envArgs.trade_group_id;
     if (!vaultGroupId) {
-        throw new Error('环境变量 TRADE_GROUP_ID 未配置');
+        throw new Error('TRADE_GROUP_ID 未配置（envArgs.trade_group_id 为空）');
     }
     const vaultWallet = (0, ttd_core_1.load_wallet)(vaultGroupId, true);
     if (!vaultWallet.public_key) {
         throw new Error(`load_wallet(${vaultGroupId}) 未返回 public_key`);
     }
-    const pancakeIdName = process.env.PANCAKE_EXECUTOR_ID || 'PANCAKE';
-    const uniswapIdName = process.env.UNISWAP_EXECUTOR_ID || 'UNISWAP';
     return {
         vaultAddress: vaultWallet.public_key,
         executorIds: {
-            pancake: ethers_compat_1.ethersCompat.id(pancakeIdName),
-            uniswap: ethers_compat_1.ethersCompat.id(uniswapIdName),
+            pancake: ethers_compat_1.ethersCompat.id(envArgs.pancake_executor_id),
+            uniswap: ethers_compat_1.ethersCompat.id(envArgs.uniswap_executor_id),
         },
     };
 }
@@ -102,7 +100,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 maxTipAmountGwei: 500000,
             }
         };
-        this.tradeConfig = buildTradeConfig();
+        this.tradeConfig = buildTradeConfig(env);
     }
     async init(transactionSender) {
         (0, fast_signer_1.patchEthersV5Signer)();
@@ -140,7 +138,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
         trace.set('input', `${amount} ${inputToken.symbol}`);
         trace.set('outputMin', `${ethers_compat_1.ethersCompat.formatUnits(amountOutMin, outputToken.decimals)} ${outputToken.symbol}`);
         trace.set('slippage', `${slippage_bps / 100}%`);
-        let maxAttempts = Math.min(Math.max(parseInt(process.env.NONCE_LOCK_MAX_RETRIES || '3'), 1), 3);
+        const maxAttempts = 3;
         const { wallet: caller, nonce: initialNonce } = await this.callerManager.acquireCaller();
         trace.mark('caller');
         trace.set('caller', caller.address);
@@ -207,7 +205,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
                 context._execution_marks = trace.getAbsoluteMarks();
                 context._execution_start_time = trace.getStartTime();
                 try {
-                    base_tx_result_checker_1.TradeResultSubscriber.getInstance().sendNonceWatch(caller.address, txid);
+                    abstract_tx_result_checker_1.TradeResultSubscriber.getInstance().sendNonceWatch(caller.address, txid);
                 }
                 catch { }
                 return txid;
@@ -245,7 +243,7 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
         return txid;
     }
     scanCallerFiles(groupId) {
-        const walletDir = process.env.WALLET_DIR || path.join((0, ttd_core_1.home_dir)(), 'data', 'keypairs');
+        const walletDir = this.appConfig.env_args.wallet_dir || path.join((0, ttd_core_1.home_dir)(), 'data', 'keypairs');
         const prefix = `${groupId}-CALLER-`;
         const files = fs.readdirSync(walletDir)
             .filter(f => f.startsWith(prefix) && f.endsWith('.json'))

package/dist/trade/caller_manager.d.ts

@@ -17,6 +17,9 @@ export declare class CallerManager {
     constructor(config: CallerManagerConfig);
     init(): Promise<void>;
     acquireCaller(): Promise<CallerHandle>;
+    private acquireCallerWithLock;
+    private acquireCallerWithLuaCas;
+    private readNonce;
     confirmNonce(address: string, confirmedNonce: number): Promise<void>;
     forceSetNonce(address: string, nonce: number): Promise<void>;
     getCallerCount(): number;

package/dist/trade/caller_manager.js

@@ -5,6 +5,27 @@ const dist_1 = require("@clonegod/ttd-core/dist");
 const logger = (0, dist_1.createLogger)(__filename);
 const ethers_1 = require("ethers");
 const ttd_core_1 = require("@clonegod/ttd-core");
+const LUA_ACQUIRE_CALLER = `
+local last_used_key = KEYS[1]
+local now = tonumber(ARGV[#ARGV])
+local count = #ARGV - 1
+
+local min_ts = nil
+local min_addr = nil
+for i = 1, count do
+    local addr = ARGV[i]
+    local ts_raw = redis.call('HGET', last_used_key, addr)
+    local ts = ts_raw and tonumber(ts_raw) or 0
+    if min_ts == nil or ts < min_ts then
+        min_ts = ts
+        min_addr = addr
+    end
+end
+if min_addr then
+    redis.call('HSET', last_used_key, min_addr, tostring(now))
+end
+return min_addr
+`;
 const CALLER_NONCE_KEY = 'caller:nonce';
 const CALLER_LAST_USED_KEY = 'caller:last_used';
 const VAULT_CALLERS_KEY = 'vault:callers';
@@ -62,6 +83,13 @@ class CallerManager {
         logger.info(`CallerManager initialized for ${this.config.groupId}: loaded=${allWallets.length}, active=${this.callers.length}, skipped=${skipped.length}`, callerSummary);
     }
     async acquireCaller() {
+        const strategy = (0, dist_1.getCoreEnv)()?.caller_select_strategy;
+        if (strategy === 'lua_cas') {
+            return this.acquireCallerWithLuaCas();
+        }
+        return this.acquireCallerWithLock();
+    }
+    async acquireCallerWithLock() {
         const lockKey = `${this.config.chainName}:caller:lock:select`;
         const lockValue = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
         const lockExpireSeconds = 1;
@@ -101,16 +129,36 @@ class CallerManager {
         finally {
             this.redis.releaseLock(lockKey, lockValue).catch(() => { });
         }
+        const nonce = await this.readNonce(callerAddr);
+        const totalMs = Date.now() - startTime;
+        const lockWaitMs = lockAcquiredTime - startTime;
+        logger.info(`acquireCaller[lock]: ${callerAddr} nonce=${nonce}, lock_wait=${lockWaitMs}ms, total=${totalMs}ms${retries > 0 ? `, retries=${retries}` : ''}`);
+        return { wallet: this.callers[selectedIdx], nonce };
+    }
+    async acquireCallerWithLuaCas() {
+        const startTime = Date.now();
+        const lastUsedKey = this.getLastUsedRedisKey();
+        const addresses = this.callers.map(w => w.address.toLowerCase());
+        const now = Date.now();
+        const selectedAddr = await this.redis.eval(LUA_ACQUIRE_CALLER, [lastUsedKey], [...addresses, String(now)]);
+        if (!selectedAddr) {
+            throw new Error('acquireCaller[lua_cas]: script returned no caller');
+        }
+        const selectedIdx = addresses.indexOf(selectedAddr);
+        if (selectedIdx < 0) {
+            throw new Error(`acquireCaller[lua_cas]: selected addr ${selectedAddr} not in pool`);
+        }
+        const nonce = await this.readNonce(selectedAddr);
+        logger.info(`acquireCaller[lua_cas]: ${selectedAddr} nonce=${nonce}, total=${Date.now() - startTime}ms`);
+        return { wallet: this.callers[selectedIdx], nonce };
+    }
+    async readNonce(callerAddr) {
         const nonceKey = this.getNonceRedisKey();
         const nonceStr = await this.redis.hget(nonceKey, callerAddr);
         if (nonceStr === null || nonceStr === undefined) {
             throw new Error(`Caller ${callerAddr} nonce not found in Redis, stream-trade may not be running`);
         }
-        const nonce = parseInt(nonceStr, 10);
-        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 };
+        return parseInt(nonceStr, 10);
     }
     async confirmNonce(address, confirmedNonce) {
         const current = await this.getNonce(address);

package/dist/trade/check/abstract_tx_result_checker.d.ts

@@ -0,0 +1,28 @@
+import { EnvArgs } from '@clonegod/ttd-core';
+import { AbstractTransactionResultCheck } from "@clonegod/ttd-core/dist/trade";
+import { EventEmitter } from 'events';
+export declare class TradeResultSubscriber {
+    private static instance;
+    private ws;
+    private connected;
+    private listeners;
+    static getInstance(): TradeResultSubscriber;
+    listen(txHash: string, callback: (receipt: any) => void, timeoutMs?: number): void;
+    remove(txHash: string): void;
+    sendNonceWatch(caller: string, txHash: string): void;
+    private cachedSubscriptions;
+    private cachedClientName;
+    private getSubscriptions;
+    private getClientName;
+    private ensureConnected;
+}
+export declare abstract class AbstractTxResultChecker extends AbstractTransactionResultCheck {
+    protected provider: any;
+    constructor(env_args: EnvArgs, event_emitter: EventEmitter);
+    protected abstract createParser(): {
+        parseTransaction(txReceipt: any, poolInfo: any): Promise<any>;
+    };
+    check_tx_result_interval(): Promise<void>;
+    on_subscibe_transaction(): Promise<void>;
+    private processTransactionResult;
+}

package/dist/trade/check/abstract_tx_result_checker.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTxResultChecker = exports.TradeResultSubscriber = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
+const trade_1 = require("@clonegod/ttd-core/dist/trade");
+const ethers_compat_1 = require("../../utils/ethers_compat");
+class TradeResultSubscriber {
+    constructor() {
+        this.ws = null;
+        this.connected = false;
+        this.listeners = new Map();
+        this.cachedSubscriptions = null;
+        this.cachedClientName = null;
+    }
+    static getInstance() {
+        if (!TradeResultSubscriber.instance) {
+            TradeResultSubscriber.instance = new TradeResultSubscriber();
+        }
+        return TradeResultSubscriber.instance;
+    }
+    listen(txHash, callback, timeoutMs = 30000) {
+        const key = txHash.toLowerCase();
+        this.listeners.set(key, callback);
+        setTimeout(() => {
+            this.listeners.delete(key);
+        }, timeoutMs);
+        this.ensureConnected();
+    }
+    remove(txHash) {
+        this.listeners.delete(txHash.toLowerCase());
+    }
+    sendNonceWatch(caller, txHash) {
+        this.ensureConnected();
+        if (this.ws && this.connected) {
+            this.ws.send(JSON.stringify({ type: 'nonceWatch', caller, txHash }));
+        }
+    }
+    getSubscriptions() {
+        if (this.cachedSubscriptions)
+            return this.cachedSubscriptions;
+        const groupIds = ((0, ttd_core_1.getCoreEnv)()?.trade_group_id || '').split(',').map(s => s.trim()).filter(Boolean);
+        const subs = [];
+        for (const gid of groupIds) {
+            const w = (0, ttd_core_1.load_wallet)(gid, true);
+            if (w.public_key) {
+                subs.push({ address: w.public_key, groupId: gid });
+            }
+        }
+        this.cachedSubscriptions = subs;
+        return subs;
+    }
+    getClientName() {
+        if (this.cachedClientName)
+            return this.cachedClientName;
+        this.cachedClientName = process.env.APP_NAME
+            || process.env.name
+            || (process.env.pm_id ? `pm2-${process.env.pm_id}` : null)
+            || `pid-${process.pid}`;
+        return this.cachedClientName;
+    }
+    ensureConnected() {
+        if (this.ws)
+            return;
+        const host = process.env.STREAM_TRADE_WS_HOST || '127.0.0.1';
+        const wsUrl = `ws://${host}:${ttd_core_1.SERVICE_PORT.STREAM_TRADE_WS}`;
+        this.ws = new ttd_core_1.WebSocketClient(wsUrl);
+        this.ws.onOpen(() => {
+            this.connected = true;
+            const subs = this.getSubscriptions();
+            const clientName = this.getClientName();
+            for (const { address, groupId } of subs) {
+                this.ws.send(JSON.stringify({ address, groupId, clientName }));
+            }
+            logger.info(`TradeResultSubscriber connected: ${wsUrl}, subscribed=${subs.length}`);
+        });
+        this.ws.onMessage((msg) => {
+            if (msg.type !== 'TradeResult' || !msg.data)
+                return;
+            const { txHash, receipt } = msg.data;
+            if (!txHash || !receipt)
+                return;
+            const key = txHash.toLowerCase();
+            const callback = this.listeners.get(key);
+            if (callback) {
+                this.listeners.delete(key);
+                callback(receipt);
+            }
+        });
+        this.ws.connect();
+    }
+}
+exports.TradeResultSubscriber = TradeResultSubscriber;
+TradeResultSubscriber.instance = null;
+class AbstractTxResultChecker extends trade_1.AbstractTransactionResultCheck {
+    constructor(env_args, event_emitter) {
+        super(env_args, event_emitter);
+        this.provider = new ethers_compat_1.ethersCompat.JsonRpcProvider(this.env_args.rpc_endpoint);
+    }
+    async check_tx_result_interval() {
+        const check_start_time = Date.now();
+        const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000');
+        const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '15000');
+        if (check_interval >= check_timeout)
+            return;
+        const intervalId = setInterval(async () => {
+            this.check_count += 1;
+            logger.info(`check transaction start: seq=[${this.check_count}], txhash=${this.txid}, trace_id=${this.trace_id}`);
+            try {
+                if (Date.now() - check_start_time < check_timeout) {
+                    let txReceipt = await this.provider.getTransactionReceipt(this.txid);
+                    if (!txReceipt)
+                        return;
+                    logger.info(`Received transaction result via polling: ${this.txid}`);
+                    clearInterval(intervalId);
+                    await this.processTransactionResult(txReceipt, 'interval');
+                }
+                else {
+                    clearInterval(intervalId);
+                }
+            }
+            catch (err) {
+                clearInterval(intervalId);
+                logger.error('parse transaction error!', err);
+            }
+        }, check_interval);
+        this.intervalId = intervalId;
+    }
+    async on_subscibe_transaction() {
+        logger.info(`Subscribing trade result, txid=${this.txid}`);
+        TradeResultSubscriber.getInstance().listen(this.txid, (receipt) => {
+            logger.info(`Received transaction result via stream-trade: ${this.txid}`);
+            this.processTransactionResult(receipt, 'websocket')
+                .catch(err => logger.error(`Error processing trade result: ${this.txid}`, err));
+        });
+    }
+    async processTransactionResult(txReceipt, source) {
+        if (ttd_core_1.LOG.debug) {
+            (0, ttd_core_1.writeFile)(`./dist/tx_receipt_${this.txid}_${source}.json`, JSON.stringify(txReceipt, null, 2));
+        }
+        if (this.trade_result_already_processed) {
+            logger.info(`trade_result_already_processed, ignore result from ${source}`);
+            return;
+        }
+        const parser = this.createParser();
+        const swap_detail = await parser.parseTransaction(txReceipt, this.pool_info);
+        let trade_result = this.map_swap_result_to_tx_result(swap_detail);
+        this.trade_result_already_processed = true;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (trade_result.success) {
+            this.event_emitter.emit(ttd_core_1.TRANSACTION_STATE_SUCCESS, trade_result);
+        }
+        else {
+            this.event_emitter.emit(ttd_core_1.TRANSACTION_STATE_FAILED, trade_result);
+        }
+        if (source === 'interval') {
+            console.log('--------------------- Transaction Result from Polling ---------------------');
+        }
+        else {
+            console.log('===================== Transaction Result from stream-trade =====================');
+        }
+        console.log(JSON.stringify(trade_result, null, 2));
+        console.log('-----------------------------------------------------------------------------');
+    }
+}
+exports.AbstractTxResultChecker = AbstractTxResultChecker;