@clonegod/ttd-bsc-send-tx 2.0.3 → 2.0.5

package/.env.example

@@ -0,0 +1,40 @@
+APP_NAME=send-tx
+
+CHAIN_ID=BSC
+
+REDIS_HOST=127.0.0.1
+REDIS_PORT=6379
+
+LOG_LEVEL=INFO
+LOG_DEPTH=4
+
+# WS client（trade 进程连 send-tx server 用）
+SEND_TX_WS_HOST=127.0.0.1
+
+# WS server 开关
+SEND_TX_48CLUB_WS=false
+SEND_TX_BLOXROUTE_WS=false
+
+# HTTP providers
+SEND_TX_DEFAULT_RPC=false
+SEND_TX_BLOCKRAZOR_PRIVATE=false
+SEND_TX_BLOCKRAZOR_BUNDLE=false
+SEND_TX_48CLUB_PRIVATE=false
+SEND_TX_48CLUB_BUNDLE=false
+SEND_TX_BLOX_BUNDLE_WS=false
+SEND_TX_48CLUB_BUNDLE_WS=false
+
+# Builder endpoints
+BSC_RPC_ENDPOINT=
+BLOXROUTE_WS_URL=
+BLOX_AUTH_KEY=
+_48CLUB_WS_URL=
+_48CLUB_RPC_URL=
+_48CLUB_SP_WALLET_ID=TTD-PAYMENT
+BLOCKRAZOR_RPC_URL=
+BLOCKRAZOR_AUTH_TOKEN=
+
+# 间接依赖（通过 ttd-core 工具函数读取）
+# load_wallet
+WALLET_DIR=
+ENCRYPTION_KEY=

package/dist/_48club/http.d.ts

@@ -1,5 +1,5 @@
 export declare class _48ClubTrade {
-    private rpcUrl;
+    private client;
     constructor();
     sendPrivateTransaction(signedTx: string): Promise<string>;
     sendPrivateTransactionWith48SP(signedTx: string): Promise<string>;

package/dist/_48club/http.js

@@ -14,15 +14,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._48ClubTrade = void 0;
 const axios_1 = __importDefault(require("axios"));
+const appconfig_1 = require("../appconfig");
+const https_1 = __importDefault(require("https"));
 const sp_signature_1 = require("./sp_signature");
 const member_1 = require("./member");
 class _48ClubTrade {
     constructor() {
-        this.rpcUrl = process.env._48CLUB_RPC_URL || 'https://puissant-builder.48.club/';
+        const rpcUrl = appconfig_1.envArgs._48club_rpc_url;
+        this.client = axios_1.default.create({
+            baseURL: rpcUrl,
+            headers: { 'Content-Type': 'application/json' },
+            httpsAgent: new https_1.default.Agent({ keepAlive: true, maxSockets: 10 }),
+            timeout: 5000,
+        });
     }
     sendPrivateTransaction(signedTx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(this.rpcUrl, {
+            const response = yield this.client.post('', {
                 jsonrpc: "2.0", id: "1",
                 method: "eth_sendRawTransaction",
                 params: [signedTx]
@@ -36,7 +44,7 @@ class _48ClubTrade {
     sendPrivateTransactionWith48SP(signedTx) {
         return __awaiter(this, void 0, void 0, function* () {
             const spSignature = yield this.get48SPSignature([signedTx]);
-            const response = yield axios_1.default.post(this.rpcUrl, {
+            const response = yield this.client.post('', {
                 jsonrpc: "2.0", id: "1",
                 method: "eth_sendPrivateTransactionWith48SP",
                 params: [signedTx, spSignature]
@@ -61,7 +69,7 @@ class _48ClubTrade {
             catch (error) {
                 console.warn(`[48Club] 生成 48SP 签名失败，将发送不带签名的 Bundle: ${error.message}`);
             }
-            const response = yield axios_1.default.post(this.rpcUrl, {
+            const response = yield this.client.post('', {
                 jsonrpc: "2.0", id: "1",
                 method: "eth_sendBundle",
                 params: [requestParams]

package/dist/_48club/member.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.get_48club_sp_private_key = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("../appconfig");
 var _48club_sp_wallet_private_key = null;
 const get_48club_sp_private_key = () => {
     if (_48club_sp_wallet_private_key) {
         return _48club_sp_wallet_private_key;
     }
     try {
-        const wallet = (0, ttd_core_1.load_wallet)(process.env._48CLUB_SP_WALLET_ID || 'TTD-PAYMENT', false);
+        const wallet = (0, ttd_core_1.load_wallet)(appconfig_1.envArgs._48club_sp_wallet_id, false);
         console.log('Load 48club SP wallet success, wallet address:', wallet.public_key);
         _48club_sp_wallet_private_key = wallet.private_key;
         return _48club_sp_wallet_private_key;

package/dist/_48club/ws.js

@@ -11,10 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._48ClubWsSender = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("../appconfig");
 class _48ClubWsSender {
     constructor() {
         this.wsClient = null;
-        this.wsUrl = process.env._48CLUB_WS_URL || 'wss://puissant-builder.48.club/';
+        this.wsUrl = appconfig_1.envArgs._48club_ws_url;
     }
     connect() {
         var _a;
@@ -36,11 +37,11 @@ class _48ClubWsSender {
     sendTransaction(request) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isConnected()) {
-                (0, ttd_core_1.log_warn)('[48club-ws] not connected');
+                (0, ttd_core_1.log_error)('[48club-ws] not connected, dropping tx', new Error('48club not connected'));
                 return;
             }
             if (!request.tipTx) {
-                (0, ttd_core_1.log_warn)('[48club-ws] tipTx required for bundle');
+                (0, ttd_core_1.log_error)('[48club-ws] tipTx required for bundle, dropping tx', new Error('tipTx required for bundle'));
                 return;
             }
             const currentTimestamp = Math.floor(Date.now() / 1000);

package/dist/appconfig/EnvArgs.d.ts

@@ -0,0 +1,24 @@
+import { EnvArgs as CoreEnvArgs } from '@clonegod/ttd-core/dist';
+import './env_registry';
+export declare class SendTxEnvArgs extends CoreEnvArgs {
+    rpc_endpoint: string;
+    wallet_dir: string;
+    encryption_key: string;
+    send_tx_ws_host: string;
+    send_tx_default_rpc: boolean;
+    send_tx_blockrazor_private: boolean;
+    send_tx_48club_private: boolean;
+    send_tx_blockrazor_bundle: boolean;
+    send_tx_48club_bundle: boolean;
+    send_tx_48club_bundle_ws: boolean;
+    send_tx_blox_bundle_ws: 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;
+    constructor();
+}

package/dist/appconfig/EnvArgs.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendTxEnvArgs = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+require("./env_registry");
+class SendTxEnvArgs extends dist_1.EnvArgs {
+    constructor() {
+        var _a, _b;
+        super();
+        const cfg = this._cfg;
+        this.app_name = (cfg.app_name || '').toLowerCase();
+        this.chain_id = (cfg.chain_id || '').toUpperCase();
+        this.server_id = (_a = cfg.server_id) !== null && _a !== void 0 ? _a : '';
+        this.redis_host = cfg.redis_host;
+        this.redis_port = String(cfg.redis_port);
+        this.rpc_endpoint = cfg.rpc_endpoint;
+        this.wallet_dir = cfg.wallet_dir;
+        this.encryption_key = (_b = cfg.encryption_key) !== null && _b !== void 0 ? _b : '';
+        this.send_tx_ws_host = cfg.send_tx_ws_host;
+        this.send_tx_default_rpc = cfg.send_tx_default_rpc;
+        this.send_tx_blockrazor_private = cfg.send_tx_blockrazor_private;
+        this.send_tx_48club_private = cfg.send_tx_48club_private;
+        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;
+        this.bsc_rpc_endpoint = cfg.bsc_rpc_endpoint;
+        this.bloxroute_ws_url = cfg.bloxroute_ws_url;
+        this.blox_auth_key = cfg.blox_auth_key;
+        this._48club_ws_url = cfg._48club_ws_url;
+        this._48club_rpc_url = cfg._48club_rpc_url;
+        this._48club_sp_wallet_id = cfg._48club_sp_wallet_id;
+        this.blockrazor_rpc_url = cfg.blockrazor_rpc_url;
+        this.blockrazor_auth_token = cfg.blockrazor_auth_token;
+        (0, dist_1.printEnvConfig)('send-tx', this);
+    }
+}
+exports.SendTxEnvArgs = SendTxEnvArgs;

package/dist/appconfig/env_registry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/appconfig/env_registry.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ttd_core_1 = require("@clonegod/ttd-core");
+(0, ttd_core_1.registerEnvVars)({
+    bloxroute_ws_url: { env: 'BLOXROUTE_WS_URL', type: 'string', default: 'wss://api.blxrbdn.com/ws', desc: 'BloxRoute WS URL（send-tx 上游）' },
+    blox_auth_key: { env: 'BLOX_AUTH_KEY', type: 'string', default: '', sensitive: true, desc: 'BloxRoute 认证 key（send-tx 上游）' },
+    _48club_ws_url: { env: '_48CLUB_WS_URL', type: 'string', default: 'wss://puissant-builder.48.club/', desc: '48Club WS URL（send-tx 上游）' },
+});

package/dist/appconfig/index.d.ts

@@ -0,0 +1,3 @@
+import { SendTxEnvArgs } from './EnvArgs';
+export { SendTxEnvArgs };
+export declare const envArgs: SendTxEnvArgs;

package/dist/appconfig/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envArgs = exports.SendTxEnvArgs = void 0;
+const EnvArgs_1 = require("./EnvArgs");
+Object.defineProperty(exports, "SendTxEnvArgs", { enumerable: true, get: function () { return EnvArgs_1.SendTxEnvArgs; } });
+exports.envArgs = new EnvArgs_1.SendTxEnvArgs();

package/dist/blockrazor/index.d.ts

@@ -1,6 +1,5 @@
 export declare class BlockRazorTrade {
-    private rpcUrl;
-    private authToken;
+    private client;
     constructor();
     sendPrivateTransaction(signedTx: string): Promise<string>;
     sendBundle(transactions: string[]): Promise<string>;

package/dist/blockrazor/index.js

@@ -14,21 +14,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockRazorTrade = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("../appconfig");
 const axios_1 = __importDefault(require("axios"));
+const https_1 = __importDefault(require("https"));
 class BlockRazorTrade {
     constructor() {
-        this.rpcUrl = process.env.BLOCKRAZOR_RPC_URL || 'https://rpc.blockrazor.builders';
-        this.authToken = process.env.BLOCKRAZOR_AUTH_TOKEN || '';
+        const rpcUrl = appconfig_1.envArgs.blockrazor_rpc_url;
+        const authToken = appconfig_1.envArgs.blockrazor_auth_token;
+        this.client = axios_1.default.create({
+            baseURL: rpcUrl,
+            headers: { 'Content-Type': 'application/json', 'Authorization': authToken },
+            httpsAgent: new https_1.default.Agent({ keepAlive: true, maxSockets: 10 }),
+            timeout: 5000,
+        });
     }
     sendPrivateTransaction(signedTx) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield axios_1.default.post(this.rpcUrl, {
+                const response = yield this.client.post('', {
                     jsonrpc: "2.0", id: "1",
                     method: "eth_sendPrivateTransaction",
                     params: [signedTx]
-                }, {
-                    headers: { 'Content-Type': 'application/json', 'Authorization': this.authToken }
                 });
                 if (response.data.error) {
                     throw new Error(`${response.data.error.code} - ${response.data.error.message}`);
@@ -45,12 +51,10 @@ class BlockRazorTrade {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const currentTimestamp = Math.floor(Date.now() / 1000);
-                const response = yield axios_1.default.post(this.rpcUrl, {
+                const response = yield this.client.post('', {
                     jsonrpc: "2.0", id: "1",
                     method: "eth_sendBundle",
                     params: [{ txs: transactions, maxTimestamp: currentTimestamp + 5 }]
-                }, {
-                    headers: { 'Content-Type': 'application/json', 'Authorization': this.authToken }
                 });
                 if (response.data.error) {
                     throw new Error(`Bundle: ${response.data.error.message}`);

package/dist/bloxroute/ws.js

@@ -11,11 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BloXRouteWsSender = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("../appconfig");
 class BloXRouteWsSender {
     constructor() {
         this.wsClient = null;
-        this.wsUrl = process.env.BLOXROUTE_WS_URL || 'wss://api.blxrbdn.com/ws';
-        this.authToken = process.env.BLOX_AUTH_KEY || '';
+        this.wsUrl = appconfig_1.envArgs.bloxroute_ws_url;
+        this.authToken = appconfig_1.envArgs.blox_auth_key;
     }
     connect() {
         var _a;
@@ -40,11 +41,11 @@ class BloXRouteWsSender {
     sendTransaction(request) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isConnected()) {
-                (0, ttd_core_1.log_warn)('[bloxroute-ws] not connected');
+                (0, ttd_core_1.log_error)('[bloxroute-ws] not connected, dropping tx', new Error('bloxroute not connected'));
                 return;
             }
             if (!request.tipTx) {
-                (0, ttd_core_1.log_warn)('[bloxroute-ws] tipTx required for bundle');
+                (0, ttd_core_1.log_error)('[bloxroute-ws] tipTx required for bundle, dropping tx', new Error('tipTx required for bundle'));
                 return;
             }
             const targetBlockNumber = request.blockNumber + 4;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { TransactionSender } from './transaction_sender';
 export { BSC_EOA_ADDRESS } from './constants';
+import './config';

package/dist/index.js

@@ -5,3 +5,4 @@ var transaction_sender_1 = require("./transaction_sender");
 Object.defineProperty(exports, "TransactionSender", { enumerable: true, get: function () { return transaction_sender_1.TransactionSender; } });
 var constants_1 = require("./constants");
 Object.defineProperty(exports, "BSC_EOA_ADDRESS", { enumerable: true, get: function () { return constants_1.BSC_EOA_ADDRESS; } });
+require("./config");

package/dist/rpc/index.js

@@ -11,9 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscMainnetRpc = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("../appconfig");
 class BscMainnetRpc {
     constructor(rpc_endpoint) {
-        this.url = rpc_endpoint || process.env.BSC_RPC_ENDPOINT || '';
+        this.url = rpc_endpoint || appconfig_1.envArgs.bsc_rpc_endpoint;
         this.headers = new Headers();
         this.headers.append("Content-Type", "application/json");
     }

package/dist/transaction_sender.d.ts

@@ -1,9 +1,13 @@
 import { AppConfig } from '@clonegod/ttd-core';
+interface TraceWriter {
+    mark(name: string): void;
+}
 export declare class TransactionSender {
     private rpc;
     private blockRazor;
     private _48Club;
     private sendBundleProxy;
     constructor(appConfig: AppConfig);
-    sendTransaction(signedMainTx: string, eoa_tip_transaction: (eoa_address: string) => Promise<string>, order_trace_id: string, pair?: string, only_bundle?: boolean): Promise<string[]>;
+    sendTransaction(signedMainTx: string, tipTxMap: Map<string, string>, order_trace_id: string, pair?: string, only_bundle?: boolean, trace?: TraceWriter): Promise<string[]>;
 }
+export {};

package/dist/transaction_sender.js

@@ -11,9 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionSender = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("./appconfig");
 const rpc_1 = require("./rpc");
 const blockrazor_1 = require("./blockrazor");
 const _48club_1 = require("./_48club");
+const sp_signature_1 = require("./_48club/sp_signature");
+const member_1 = require("./_48club/member");
 const ws_client_1 = require("./ws_client");
 const constants_1 = require("./constants");
 class TransactionSender {
@@ -23,93 +26,102 @@ class TransactionSender {
         this._48Club = new _48club_1._48ClubTrade();
         this.sendBundleProxy = new ws_client_1.BscSendTxProxy();
     }
-    sendTransaction(signedMainTx_1, eoa_tip_transaction_1, order_trace_id_1) {
-        return __awaiter(this, arguments, void 0, function* (signedMainTx, eoa_tip_transaction, order_trace_id, pair = '', only_bundle = false) {
-            const rpcProviders = [
+    sendTransaction(signedMainTx_1, tipTxMap_1, order_trace_id_1) {
+        return __awaiter(this, arguments, void 0, function* (signedMainTx, tipTxMap, order_trace_id, pair = '', only_bundle = false, trace) {
+            const results = [];
+            const errors = [];
+            if (appconfig_1.envArgs.send_tx_blox_bundle_ws) {
+                try {
+                    const tipTx = tipTxMap.get(constants_1.BSC_EOA_ADDRESS.BLXR);
+                    this.sendBundleProxy.sendTransaction('bloxroute', pair, signedMainTx, tipTx);
+                    results.push('sent to bloxroute ws');
+                }
+                catch (error) {
+                    errors.push(`bloxroute_ws: ${error.message}`);
+                    (0, ttd_core_1.log_info)(`Transaction send failed`, { provider: 'bloxroute_ws', order_trace_id, error: error.message });
+                }
+            }
+            if (appconfig_1.envArgs.send_tx_48club_bundle_ws) {
+                try {
+                    const tipTx = tipTxMap.get(constants_1.BSC_EOA_ADDRESS._48CLUB);
+                    let spSignature;
+                    try {
+                        const privateKey = (0, member_1.get_48club_sp_private_key)();
+                        if (privateKey) {
+                            spSignature = sp_signature_1.SoulPointSignature.generate48SPSignature(privateKey, [signedMainTx, tipTx]);
+                        }
+                    }
+                    catch (_a) { }
+                    this.sendBundleProxy.sendTransaction('48club', pair, signedMainTx, tipTx, spSignature);
+                    results.push('sent to 48club ws');
+                }
+                catch (error) {
+                    errors.push(`48club_ws: ${error.message}`);
+                    (0, ttd_core_1.log_info)(`Transaction send failed`, { provider: '48club_ws', order_trace_id, error: error.message });
+                }
+            }
+            trace === null || trace === void 0 ? void 0 : trace.mark('ws_sent');
+            const httpProviders = [
                 {
-                    name: 'Default RPC',
-                    enable: process.env.SEND_TX_DEFAULT_RPC_PRIVATE === 'true',
+                    name: 'default_rpc',
+                    enable: appconfig_1.envArgs.send_tx_default_rpc,
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this.rpc.eth_sendRawTransaction(signedMainTx); }),
                 },
                 {
-                    name: 'BlockRazor HTTP Private',
-                    enable: process.env.SEND_TX_BLOCKRAZOR_PRIVATE === 'true',
+                    name: 'blockrazor_private',
+                    enable: appconfig_1.envArgs.send_tx_blockrazor_private,
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this.blockRazor.sendPrivateTransaction(signedMainTx); }),
                 },
                 {
-                    name: 'BlockRazor HTTP Bundle',
-                    enable: process.env.SEND_TX_BLOCKRAZOR_BUNDLE === 'true',
+                    name: 'blockrazor_bundle',
+                    enable: appconfig_1.envArgs.send_tx_blockrazor_bundle,
                     is_bundle: true,
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        const bundle = [signedMainTx, yield eoa_tip_transaction(constants_1.BSC_EOA_ADDRESS.BLOCKRAZOR)];
-                        return this.blockRazor.sendBundle(bundle);
+                        const tipTx = tipTxMap.get(constants_1.BSC_EOA_ADDRESS.BLOCKRAZOR);
+                        return this.blockRazor.sendBundle([signedMainTx, tipTx]);
                     }),
                 },
                 {
-                    name: '48Club HTTP Private with 48SP',
-                    enable: process.env.SEND_TX_48CLUB_PRIVATE === 'true',
+                    name: '48club_private',
+                    enable: appconfig_1.envArgs.send_tx_48club_private,
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this._48Club.sendPrivateTransactionWith48SP(signedMainTx); }),
                 },
                 {
-                    name: '48Club HTTP Bundle',
-                    enable: process.env.SEND_TX_48CLUB_BUNDLE === 'true',
+                    name: '48club_bundle',
+                    enable: appconfig_1.envArgs.send_tx_48club_bundle,
                     is_bundle: true,
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        const bundle = [signedMainTx, yield eoa_tip_transaction(constants_1.BSC_EOA_ADDRESS._48CLUB)];
-                        return this._48Club.sendBundle({ txs: bundle });
-                    }),
-                },
-                {
-                    name: '48Club WS Bundle',
-                    enable: process.env.SEND_TX_48CLUB_BUNDLE_WS === 'true',
-                    is_bundle: true,
-                    send: () => __awaiter(this, void 0, void 0, function* () {
-                        const tipTx = yield eoa_tip_transaction(constants_1.BSC_EOA_ADDRESS._48CLUB);
-                        const spSignature = yield this._48Club.get48SPSignature([signedMainTx, tipTx]);
-                        this.sendBundleProxy.sendTransaction('48club', pair, signedMainTx, tipTx, spSignature);
-                        return 'sent to 48club ws';
-                    }),
-                },
-                {
-                    name: 'BloxRoute WS Bundle',
-                    enable: process.env.SEND_TX_BLOX_BUNDLE_WS === 'true',
-                    is_bundle: true,
-                    send: () => __awaiter(this, void 0, void 0, function* () {
-                        const tipTx = yield eoa_tip_transaction(constants_1.BSC_EOA_ADDRESS.BLXR);
-                        this.sendBundleProxy.sendTransaction('bloxroute', pair, signedMainTx, tipTx);
-                        return 'sent to bloxroute ws';
+                        const tipTx = tipTxMap.get(constants_1.BSC_EOA_ADDRESS._48CLUB);
+                        return this._48Club.sendBundle({ txs: [signedMainTx, tipTx] });
                     }),
                 },
             ];
-            const results = [];
-            const errors = [];
-            yield Promise.all(rpcProviders
+            yield Promise.all(httpProviders
                 .filter(p => p.enable)
                 .filter(p => only_bundle ? p.is_bundle : true)
                 .map((provider) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const txHash = yield provider.send();
                     results.push(txHash);
-                    (0, ttd_core_1.log_info)(`Transaction sent`, { provider: provider.name, order_trace_id, txHash });
                 }
                 catch (error) {
                     errors.push(`${provider.name}: ${error.message}`);
-                    (0, ttd_core_1.log_info)(`Transaction failed`, { provider: provider.name, order_trace_id, error: error.message });
+                    (0, ttd_core_1.log_info)(`Transaction send failed`, { provider: provider.name, order_trace_id, error: error.message });
                 }
             })));
-            if (errors.some(e => e.includes('nonce'))) {
-                throw new Error(`Nonce error: ${JSON.stringify(errors)}`);
+            if (results.length > 0) {
+                return results;
             }
             if (errors.some(e => e.includes('bundle already exist') || e.includes('already known'))) {
                 return results;
             }
-            if (results.length === 0 || errors.length > 0) {
-                throw new Error(`Send failed: ${JSON.stringify(errors)}`);
+            if (errors.some(e => e.includes('nonce'))) {
+                throw new Error(`Nonce error: ${JSON.stringify(errors)}`);
             }
-            return results;
+            throw new Error(`Send failed: ${JSON.stringify(errors)}`);
         });
     }
 }

package/dist/ws_client.d.ts

@@ -1,6 +1,9 @@
 export declare class BscSendTxProxy {
     private wsUrl;
     private ws;
+    private clientName;
+    private connected;
+    private pendingQueue;
     constructor();
     sendTransaction(builder: '48club' | 'bloxroute', pair: string, mainTx: string, tipTx: string, _48spSign?: string): void;
 }

package/dist/ws_client.js

@@ -2,17 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscSendTxProxy = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("./appconfig");
+const logger = (0, ttd_core_1.createLogger)(__filename);
 class BscSendTxProxy {
     constructor() {
-        const host = process.env.SEND_TX_WS_HOST || '127.0.0.1';
+        this.connected = false;
+        this.pendingQueue = [];
+        const host = appconfig_1.envArgs.send_tx_ws_host;
         this.wsUrl = `ws://${host}:${ttd_core_1.SERVICE_PORT.SEND_TX_WS}/bsc/send_tx`;
+        this.clientName = process.env.APP_NAME
+            || process.env.name
+            || (process.env.pm_id ? `pm2-${process.env.pm_id}` : `pid-${process.pid}`);
         this.ws = new ttd_core_1.WebSocketClient(this.wsUrl);
-        this.ws.onOpen(() => console.log('BscSendTxProxy connected:', this.wsUrl));
-        this.ws.onMessage((message) => console.log('BscSendTxProxy response:', message));
+        this.ws.onOpen(() => {
+            this.connected = true;
+            this.ws.send(JSON.stringify({ type: 'hello', clientName: this.clientName }));
+            const flushed = this.pendingQueue.length;
+            if (flushed > 0) {
+                for (const msg of this.pendingQueue) {
+                    this.ws.send(msg);
+                }
+                this.pendingQueue.length = 0;
+            }
+            logger.info(`BscSendTxProxy connected: ${this.wsUrl}, client=${this.clientName}, flushed=${flushed}`);
+        });
+        this.ws.onMessage((message) => logger.debug(`BscSendTxProxy response`, message));
         this.ws.connect();
     }
     sendTransaction(builder, pair, mainTx, tipTx, _48spSign = null) {
-        this.ws.send(JSON.stringify({ builder, pair, mainTx, tipTx, _48spSign }));
+        const msg = JSON.stringify({ builder, pair, mainTx, tipTx, _48spSign });
+        if (this.connected) {
+            this.ws.send(msg);
+        }
+        else {
+            if (this.pendingQueue.length < 100) {
+                this.pendingQueue.push(msg);
+            }
+        }
     }
 }
 exports.BscSendTxProxy = BscSendTxProxy;

package/dist/ws_server.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 require('dotenv').config();
 const ttd_core_1 = require("@clonegod/ttd-core");
+const appconfig_1 = require("./appconfig");
+(0, ttd_core_1.setCoreEnv)(appconfig_1.envArgs);
 const ws_1 = require("ws");
 const _48club_1 = require("./_48club");
 const bloxroute_1 = require("./bloxroute");
@@ -18,6 +20,8 @@ class BscSendTxWebSocketServer {
     constructor(appConfig, serverPort = ttd_core_1.SERVICE_PORT.SEND_TX_WS) {
         this.wss = null;
         this.latestBlockNumber = 0;
+        this.clientNames = new WeakMap();
+        this.connectedCount = 0;
         this._48clubWsSender = null;
         this.bloxrouteWsSender = null;
         this.appConfig = appConfig;
@@ -33,19 +37,41 @@ class BscSendTxWebSocketServer {
         this.initSenders();
     }
     initSenders() {
-        if (process.env.SEND_TX_48CLUB_WS === 'true') {
-            this._48clubWsSender = new _48club_1._48ClubWsSender();
-            this._48clubWsSender.connect();
+        if (appconfig_1.envArgs._48club_ws_url) {
+            try {
+                this._48clubWsSender = new _48club_1._48ClubWsSender();
+                this._48clubWsSender.connect();
+                (0, ttd_core_1.log_info)(`[WS_SERVER] 48Club upstream WS client started → ${appconfig_1.envArgs._48club_ws_url}`);
+            }
+            catch (e) {
+                (0, ttd_core_1.log_error)('[WS_SERVER] 48Club upstream init failed', e instanceof Error ? e : new Error(String(e)));
+            }
         }
-        if (process.env.SEND_TX_BLOXROUTE_WS === 'true') {
-            this.bloxrouteWsSender = new bloxroute_1.BloXRouteWsSender();
-            this.bloxrouteWsSender.connect();
+        if (appconfig_1.envArgs.bloxroute_ws_url && appconfig_1.envArgs.blox_auth_key) {
+            try {
+                this.bloxrouteWsSender = new bloxroute_1.BloXRouteWsSender();
+                this.bloxrouteWsSender.connect();
+                (0, ttd_core_1.log_info)(`[WS_SERVER] BloxRoute upstream WS client started → ${appconfig_1.envArgs.bloxroute_ws_url}`);
+            }
+            catch (e) {
+                (0, ttd_core_1.log_error)('[WS_SERVER] BloxRoute upstream init failed', e instanceof Error ? e : new Error(String(e)));
+            }
+        }
+        else if (appconfig_1.envArgs.bloxroute_ws_url && !appconfig_1.envArgs.blox_auth_key) {
+            (0, ttd_core_1.log_info)(`[WS_SERVER] BloxRoute upstream skipped: BLOX_AUTH_KEY 未配置`);
         }
     }
     handleMessage(ws, message) {
         var _a, _b;
         try {
-            const request = JSON.parse(message);
+            const parsed = JSON.parse(message);
+            if (parsed.type === 'hello') {
+                this.clientNames.set(ws, parsed.clientName || 'unknown');
+                this.connectedCount++;
+                (0, ttd_core_1.log_info)(`[WS_SERVER] client connected: ${parsed.clientName}, total=${this.connectedCount}`);
+                return;
+            }
+            const request = parsed;
             if (!request.mainTx || !request.builder || !request.tipTx) {
                 ws.send(JSON.stringify({ error: 'Missing required fields: mainTx, builder, tipTx' }));
                 return;
@@ -71,9 +97,12 @@ class BscSendTxWebSocketServer {
                 return;
             this.wss = new ws_1.WebSocketServer({ port: this.serverPort });
             this.wss.on('connection', (ws) => {
-                (0, ttd_core_1.log_info)(`[WS_SERVER] client connected`);
                 ws.on('message', (msg) => this.handleMessage(ws, msg.toString()));
-                ws.on('close', () => (0, ttd_core_1.log_info)(`[WS_SERVER] client disconnected`));
+                ws.on('close', () => {
+                    const name = this.clientNames.get(ws) || 'unknown';
+                    this.connectedCount = Math.max(0, this.connectedCount - 1);
+                    (0, ttd_core_1.log_info)(`[WS_SERVER] client disconnected: ${name}, total=${this.connectedCount}`);
+                });
                 ws.on('error', (err) => (0, ttd_core_1.log_error)(`[WS_SERVER] ws error`, err));
             });
             (0, ttd_core_1.log_info)(`[WS_SERVER] started on port ${this.serverPort}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-send-tx",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "BSC 交易发送模块（HTTP直发 + WS bundle 转发）",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -12,8 +12,8 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.0.8",
-    "axios": "^1.12.0",
+    "@clonegod/ttd-core": "3.1.52",
+    "axios": "1.15.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",
     "ws": "^8.18.3"