@clonegod/ttd-bsc-send-tx 1.0.0

package/src/transaction_sender.ts

@@ -0,0 +1,123 @@
+import { AppConfig, log_info } from '@clonegod/ttd-core';
+import { BscMainnetRpc } from "./rpc";
+import { BlockRazorTrade } from "./blockrazor";
+import { _48ClubTrade } from "./_48club";
+import { BscSendTxProxy } from "./ws_client";
+import { BSC_EOA_ADDRESS } from "./constants";
+
+/**
+ * 交易发送编排器
+ * 管理所有发送通道（HTTP 直发 + WS bundle 转发），并行发送
+ */
+export class TransactionSender {
+    private rpc: BscMainnetRpc;
+    private blockRazor: BlockRazorTrade;
+    private _48Club: _48ClubTrade;
+    private sendBundleProxy: BscSendTxProxy;
+
+    constructor(appConfig: AppConfig) {
+        this.rpc = new BscMainnetRpc(appConfig.env_args.rpc_endpoint);
+        this.blockRazor = new BlockRazorTrade();
+        this._48Club = new _48ClubTrade();
+        this.sendBundleProxy = new BscSendTxProxy();
+    }
+
+    async sendTransaction(
+        signedMainTx: string,
+        eoa_tip_transaction: (eoa_address: string) => Promise<string>,
+        order_trace_id: string,
+        pair: string = '',
+        only_bundle: boolean = false
+    ): Promise<string[]> {
+        const rpcProviders = [
+            {
+                name: 'Default RPC',
+                enable: process.env.SEND_TX_DEFAULT_RPC_PRIVATE === 'true',
+                is_bundle: false,
+                send: async () => this.rpc.eth_sendRawTransaction(signedMainTx),
+            },
+            {
+                name: 'BlockRazor HTTP Private',
+                enable: process.env.SEND_TX_BLOCKRAZOR_PRIVATE === 'true',
+                is_bundle: false,
+                send: async () => this.blockRazor.sendPrivateTransaction(signedMainTx),
+            },
+            {
+                name: 'BlockRazor HTTP Bundle',
+                enable: process.env.SEND_TX_BLOCKRAZOR_BUNDLE === 'true',
+                is_bundle: true,
+                send: async () => {
+                    const bundle = [signedMainTx, await eoa_tip_transaction(BSC_EOA_ADDRESS.BLOCKRAZOR)];
+                    return this.blockRazor.sendBundle(bundle);
+                },
+            },
+            {
+                name: '48Club HTTP Private',
+                enable: process.env.SEND_TX_48CLUB_PRIVATE === 'true',
+                is_bundle: false,
+                send: async () => this._48Club.sendPrivateTransactionWith48SP(signedMainTx),
+            },
+            {
+                name: '48Club HTTP Bundle',
+                enable: process.env.SEND_TX_48CLUB_BUNDLE === 'true',
+                is_bundle: true,
+                send: async () => {
+                    const bundle = [signedMainTx, await eoa_tip_transaction(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: async () => {
+                    const tipTx = await eoa_tip_transaction(BSC_EOA_ADDRESS._48CLUB);
+                    const spSignature = await 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: async () => {
+                    const tipTx = await eoa_tip_transaction(BSC_EOA_ADDRESS.BLXR);
+                    this.sendBundleProxy.sendTransaction('bloxroute', pair, signedMainTx, tipTx);
+                    return 'sent to bloxroute ws';
+                },
+            },
+        ];
+
+        const results: string[] = [];
+        const errors: string[] = [];
+
+        await Promise.all(
+            rpcProviders
+                .filter(p => p.enable)
+                .filter(p => only_bundle ? p.is_bundle : true)
+                .map(async (provider) => {
+                    try {
+                        const txHash = await provider.send();
+                        results.push(txHash);
+                        log_info(`Transaction sent`, { provider: provider.name, order_trace_id, txHash });
+                    } catch (error: any) {
+                        errors.push(`${provider.name}: ${error.message}`);
+                        log_info(`Transaction 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 (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)}`);
+        }
+
+        return results;
+    }
+}

package/src/types/index.ts

@@ -0,0 +1,8 @@
+export interface BscSendTxRequestType {
+    builder: '48club' | 'bloxroute'
+    pair: string
+    mainTx: string
+    tipTx: string
+    _48spSign: string
+    blockNumber: number
+}

package/src/ws_client.ts

@@ -0,0 +1,22 @@
+import { WebSocketClient, SERVICE_PORT } from '@clonegod/ttd-core';
+
+/**
+ * WS Client — trade 进程通过此客户端连接 WS Server，提交 bundle 请求
+ */
+export class BscSendTxProxy {
+    private wsUrl: string;
+    private ws: WebSocketClient;
+
+    constructor() {
+        const host = process.env.SEND_TX_WS_HOST || '127.0.0.1';
+        this.wsUrl = `ws://${host}:${SERVICE_PORT.SEND_TX_WS}/bsc/send_tx`;
+        this.ws = new WebSocketClient(this.wsUrl);
+        this.ws.onOpen(() => console.log('BscSendTxProxy connected:', this.wsUrl));
+        this.ws.onMessage((message: any) => console.log('BscSendTxProxy response:', message));
+        this.ws.connect();
+    }
+
+    sendTransaction(builder: '48club' | 'bloxroute', pair: string, mainTx: string, tipTx: string, _48spSign: string = null as any) {
+        this.ws.send(JSON.stringify({ builder, pair, mainTx, tipTx, _48spSign }));
+    }
+}

package/src/ws_server.ts

@@ -0,0 +1,104 @@
+/**
+ * WS Server — 接收 trade 进程提交的 bundle 请求，转发给 Builder
+ *
+ * 启动方式：node dist/ws_server.js
+ */
+require('dotenv').config();
+
+import { AppConfig, CHAIN_ID, log_error, log_info, SERVICE_PORT } from '@clonegod/ttd-core';
+import { WebSocketServer, WebSocket } from 'ws';
+import { BscSendTxRequestType } from './types';
+import { _48ClubWsSender } from './_48club';
+import { BloXRouteWsSender } from './bloxroute';
+
+class BscSendTxWebSocketServer {
+    private wss: WebSocketServer | null = null;
+    private serverPort: number;
+    private appConfig: AppConfig;
+    private latestBlockNumber: number = 0;
+
+    private _48clubWsSender: _48ClubWsSender | null = null;
+    private bloxrouteWsSender: BloXRouteWsSender | null = null;
+
+    constructor(appConfig: AppConfig, serverPort: number = SERVICE_PORT.SEND_TX_WS) {
+        this.appConfig = appConfig;
+        this.serverPort = serverPort;
+
+        this.appConfig.arb_event_subscriber.subscribe_new_block(CHAIN_ID.BSC, (data: string) => {
+            try {
+                this.latestBlockNumber = JSON.parse(data).blockNumber;
+            } catch (error) {
+                log_error('parse block update event failed', error);
+            }
+        });
+
+        this.initSenders();
+    }
+
+    private initSenders(): void {
+        if (process.env.SEND_TX_48CLUB_WS === 'true') {
+            this._48clubWsSender = new _48ClubWsSender();
+            this._48clubWsSender.connect();
+        }
+        if (process.env.SEND_TX_BLOXROUTE_WS === 'true') {
+            this.bloxrouteWsSender = new BloXRouteWsSender();
+            this.bloxrouteWsSender.connect();
+        }
+    }
+
+    private handleMessage(ws: WebSocket, message: string): void {
+        try {
+            const request: BscSendTxRequestType = JSON.parse(message);
+
+            if (!request.mainTx || !request.builder || !request.tipTx) {
+                ws.send(JSON.stringify({ error: 'Missing required fields: mainTx, builder, tipTx' }));
+                return;
+            }
+
+            request.blockNumber = this.latestBlockNumber;
+            log_info(`[WS_SERVER] recv bundle request`, { builder: request.builder, pair: request.pair });
+
+            switch (request.builder) {
+                case '48club':
+                    this._48clubWsSender?.sendTransaction(request);
+                    break;
+                case 'bloxroute':
+                    this.bloxrouteWsSender?.sendTransaction(request);
+                    break;
+            }
+        } catch (error: any) {
+            log_error(`[WS_SERVER] handle request failed`, error);
+        }
+    }
+
+    async start(): Promise<void> {
+        if (this.wss) return;
+
+        this.wss = new WebSocketServer({ port: this.serverPort });
+
+        this.wss.on('connection', (ws: WebSocket) => {
+            log_info(`[WS_SERVER] client connected`);
+            ws.on('message', (msg: Buffer) => this.handleMessage(ws, msg.toString()));
+            ws.on('close', () => log_info(`[WS_SERVER] client disconnected`));
+            ws.on('error', (err: Error) => log_error(`[WS_SERVER] ws error`, err));
+        });
+
+        log_info(`[WS_SERVER] started on port ${this.serverPort}`);
+    }
+}
+
+// 启动入口
+process.on('uncaughtException', (err) => { log_error(`[BSC_SEND_TX] uncaught exception`, err); process.exit(1); });
+process.on('unhandledRejection', (reason) => { log_error(`[BSC_SEND_TX] unhandled rejection`, reason instanceof Error ? reason : new Error(String(reason))); process.exit(1); });
+
+const main = async () => {
+    const appConfig = new AppConfig();
+    await appConfig.init();
+    await appConfig.subscribe_config_change();
+
+    const wsPort = SERVICE_PORT.SEND_TX_WS;
+    const server = new BscSendTxWebSocketServer(appConfig, wsPort);
+    await server.start();
+};
+
+main().catch((err) => { log_error(`[BSC_SEND_TX] startup failed`, err); process.exit(1); });

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+      "typeRoots": [
+          "./node_modules/@types",
+          "./types",
+      ],
+      "lib": [
+          "es2015",
+          "dom"
+      ],
+      "module": "CommonJS",
+      "target": "es6",
+      "rootDirs": [
+          "src"
+      ],
+      "outDir": "./dist",
+      "declaration": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "resolveJsonModule": true,
+      "removeComments": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist"]
+}