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

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,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._48ClubTrade = void 0;
 const axios_1 = __importDefault(require("axios"));
+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 = process.env._48CLUB_RPC_URL || 'https://puissant-builder.48.club/';
+        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 +43,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 +68,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/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

@@ -15,20 +15,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockRazorTrade = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
 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 = process.env.BLOCKRAZOR_RPC_URL || 'https://rpc.blockrazor.builders';
+        const authToken = process.env.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 +50,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/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

@@ -14,6 +14,8 @@ const ttd_core_1 = require("@clonegod/ttd-core");
 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,81 +25,90 @@ 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 (process.env.SEND_TX_BLOX_BUNDLE_WS === 'true') {
+                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 (process.env.SEND_TX_48CLUB_BUNDLE_WS === 'true') {
+                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',
+                    name: 'default_rpc',
                     enable: process.env.SEND_TX_DEFAULT_RPC_PRIVATE === 'true',
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this.rpc.eth_sendRawTransaction(signedMainTx); }),
                 },
                 {
-                    name: 'BlockRazor HTTP Private',
+                    name: 'blockrazor_private',
                     enable: process.env.SEND_TX_BLOCKRAZOR_PRIVATE === 'true',
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this.blockRazor.sendPrivateTransaction(signedMainTx); }),
                 },
                 {
-                    name: 'BlockRazor HTTP Bundle',
+                    name: 'blockrazor_bundle',
                     enable: process.env.SEND_TX_BLOCKRAZOR_BUNDLE === 'true',
                     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',
+                    name: '48club_private',
                     enable: process.env.SEND_TX_48CLUB_PRIVATE === 'true',
                     is_bundle: false,
                     send: () => __awaiter(this, void 0, void 0, function* () { return this._48Club.sendPrivateTransactionWith48SP(signedMainTx); }),
                 },
                 {
-                    name: '48Club HTTP Bundle',
+                    name: '48club_bundle',
                     enable: process.env.SEND_TX_48CLUB_BUNDLE === 'true',
                     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'))) {

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,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscSendTxProxy = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
 class BscSendTxProxy {
     constructor() {
+        this.connected = false;
+        this.pendingQueue = [];
         const host = process.env.SEND_TX_WS_HOST || '127.0.0.1';
         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

@@ -18,6 +18,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;
@@ -45,7 +47,14 @@ class BscSendTxWebSocketServer {
     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 +80,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.4",
   "description": "BSC 交易发送模块（HTTP直发 + WS bundle 转发）",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.0.8",
+    "@clonegod/ttd-core": "3.0.13",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",