@clonegod/ttd-bsc-send-tx 1.0.0

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ws_client.d.ts

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

package/dist/ws_client.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BscSendTxProxy = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+class BscSendTxProxy {
+    constructor() {
+        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.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.connect();
+    }
+    sendTransaction(builder, pair, mainTx, tipTx, _48spSign = null) {
+        this.ws.send(JSON.stringify({ builder, pair, mainTx, tipTx, _48spSign }));
+    }
+}
+exports.BscSendTxProxy = BscSendTxProxy;

package/dist/ws_server.d.ts

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

package/dist/ws_server.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require('dotenv').config();
+const ttd_core_1 = require("@clonegod/ttd-core");
+const ws_1 = require("ws");
+const _48club_1 = require("./_48club");
+const bloxroute_1 = require("./bloxroute");
+class BscSendTxWebSocketServer {
+    constructor(appConfig, serverPort = ttd_core_1.SERVICE_PORT.SEND_TX_WS) {
+        this.wss = null;
+        this.latestBlockNumber = 0;
+        this._48clubWsSender = null;
+        this.bloxrouteWsSender = null;
+        this.appConfig = appConfig;
+        this.serverPort = serverPort;
+        this.appConfig.arb_event_subscriber.subscribe_new_block(ttd_core_1.CHAIN_ID.BSC, (data) => {
+            try {
+                this.latestBlockNumber = JSON.parse(data).blockNumber;
+            }
+            catch (error) {
+                (0, ttd_core_1.log_error)('parse block update event failed', error);
+            }
+        });
+        this.initSenders();
+    }
+    initSenders() {
+        if (process.env.SEND_TX_48CLUB_WS === 'true') {
+            this._48clubWsSender = new _48club_1._48ClubWsSender();
+            this._48clubWsSender.connect();
+        }
+        if (process.env.SEND_TX_BLOXROUTE_WS === 'true') {
+            this.bloxrouteWsSender = new bloxroute_1.BloXRouteWsSender();
+            this.bloxrouteWsSender.connect();
+        }
+    }
+    handleMessage(ws, message) {
+        var _a, _b;
+        try {
+            const request = 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;
+            (0, ttd_core_1.log_info)(`[WS_SERVER] recv bundle request`, { builder: request.builder, pair: request.pair });
+            switch (request.builder) {
+                case '48club':
+                    (_a = this._48clubWsSender) === null || _a === void 0 ? void 0 : _a.sendTransaction(request);
+                    break;
+                case 'bloxroute':
+                    (_b = this.bloxrouteWsSender) === null || _b === void 0 ? void 0 : _b.sendTransaction(request);
+                    break;
+            }
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`[WS_SERVER] handle request failed`, error);
+        }
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.wss)
+                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('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}`);
+        });
+    }
+}
+process.on('uncaughtException', (err) => { (0, ttd_core_1.log_error)(`[BSC_SEND_TX] uncaught exception`, err); process.exit(1); });
+process.on('unhandledRejection', (reason) => { (0, ttd_core_1.log_error)(`[BSC_SEND_TX] unhandled rejection`, reason instanceof Error ? reason : new Error(String(reason))); process.exit(1); });
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const appConfig = new ttd_core_1.AppConfig();
+    yield appConfig.init();
+    yield appConfig.subscribe_config_change();
+    const wsPort = ttd_core_1.SERVICE_PORT.SEND_TX_WS;
+    const server = new BscSendTxWebSocketServer(appConfig, wsPort);
+    yield server.start();
+});
+main().catch((err) => { (0, ttd_core_1.log_error)(`[BSC_SEND_TX] startup failed`, err); process.exit(1); });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@clonegod/ttd-bsc-send-tx",
+  "version": "1.0.0",
+  "description": "BSC 交易发送模块（HTTP直发 + WS bundle 转发）",
+  "license": "UNLICENSED",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf dist node_modules",
+    "build": "tsc --outDir ./dist",
+    "start": "node dist/ws_server.js",
+    "push": "npm run build && npm publish"
+  },
+  "dependencies": {
+    "@clonegod/ttd-core": "3.0.8",
+    "axios": "^1.12.0",
+    "dotenv": "^16.4.7",
+    "ethers": "^5.8.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/deploy.sh

@@ -0,0 +1,29 @@
+echo $PWD
+
+module_name="ttd-bsc-send-tx"
+
+# Delete Old File
+rm -rf dist
+rm -rf deploy
+
+# Create deploy folder
+date_time=`date +%Y%m%d-%H%M%S`
+target_dir=deploy/${date_time}/${module_name}
+mkdir -p ${target_dir}
+
+# Build
+npm run build
+
+# Copy dist and package.json
+cp -r dist ${target_dir}
+cp package.json ${target_dir}
+
+# Delete .d.ts file
+find ${target_dir} -maxdepth 3 -name "*.d.ts" -type f -delete
+
+# Show files
+tree ${target_dir}
+
+cat package.json | grep "ttd-core"
+cat package.json | grep "ttd-bsc-common" || true
+

package/scripts/start-ttd-bsc-send-tx-ws.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+echo "args count: $#"
+echo "$@"
+echo
+
+# args
+app_id="ttd-bsc-send-tx-ws"
+app_ns="BSC"
+
+# sync code
+git pull
+yarn install 
+npm run build
+
+# start app
+echo "$app_id ($app_ns)"
+
+pm2 del $app_id 2> /dev/null || true && pm2 start "dist/ws_server.js" --name $app_id --namespace $app_ns
+
+echo
+
+pm2 log $app_id
+

package/src/_48club/http.ts

@@ -0,0 +1,60 @@
+import axios from 'axios';
+import { SoulPointSignature } from './sp_signature';
+import { get_48club_sp_private_key } from './member';
+
+/**
+ * 48Club HTTP API
+ * https://docs.48.club/puissant-builder
+ */
+export class _48ClubTrade {
+    private rpcUrl: string;
+
+    constructor() {
+        this.rpcUrl = process.env._48CLUB_RPC_URL || 'https://puissant-bsc.48.club';
+    }
+
+    async sendPrivateTransactionWith48SP(signedTx: string): Promise<string> {
+        const spSign = await this.get48SPSignature([signedTx]);
+
+        const response = await axios.post(this.rpcUrl, {
+            jsonrpc: "2.0", id: 1,
+            method: "eth_sendPrivateTransaction",
+            params: [{ tx: signedTx, preferences: { '48spSign': spSign } }]
+        }, {
+            headers: { 'Content-Type': 'application/json' }
+        });
+
+        if (response.data.error) {
+            throw new Error(`48club private tx: ${response.data.error.message}`);
+        }
+        return response.data.result;
+    }
+
+    async sendBundle(params: { txs: string[] }): Promise<string> {
+        const currentTimestamp = Math.floor(Date.now() / 1000);
+        const spSign = await this.get48SPSignature(params.txs);
+
+        const response = await axios.post(this.rpcUrl, {
+            jsonrpc: "2.0", id: 1,
+            method: "eth_sendBundle",
+            params: [{
+                txs: params.txs,
+                maxTimestamp: currentTimestamp + 2,
+                '48spSign': spSign
+            }]
+        }, {
+            headers: { 'Content-Type': 'application/json' }
+        });
+
+        if (response.data.error) {
+            throw new Error(`48club bundle: ${response.data.error.message}`);
+        }
+        return response.data.result;
+    }
+
+    async get48SPSignature(txs: string[]): Promise<string> {
+        const privateKey = get_48club_sp_private_key();
+        if (!privateKey) return '';
+        return SoulPointSignature.generate48SPSignature(privateKey, txs);
+    }
+}

package/src/_48club/index.ts

@@ -0,0 +1,4 @@
+export { _48ClubTrade } from './http';
+export { _48ClubWsSender } from './ws';
+export { SoulPointSignature } from './sp_signature';
+export { get_48club_sp_private_key } from './member';

package/src/_48club/member.ts

@@ -0,0 +1,19 @@
+import { load_wallet } from '@clonegod/ttd-core';
+
+var _48club_sp_wallet_private_key: string | null = null;
+
+export const get_48club_sp_private_key = (): string | null => {
+    if (_48club_sp_wallet_private_key) {
+        return _48club_sp_wallet_private_key;
+    }
+
+    try {
+        const wallet = load_wallet(process.env._48CLUB_SP_WALLET_ID || 'TTD-PAYMENT');
+        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;
+    } catch (error: any) {
+        console.error('Load 48club SP wallet failed:' + error.message);
+        return null;
+    }
+};

package/src/_48club/sp_signature.ts

@@ -0,0 +1,28 @@
+import { ethers } from 'ethers';
+
+/**
+ * 48 SoulPoint 签名
+ * https://docs.48.club/puissant-builder/48-soulpoint-benefits
+ */
+export class SoulPointSignature {
+    static generate48SPSignature(privateKey: string, txs: string[]): string {
+        const wallet = new ethers.Wallet(privateKey);
+        const txHashes = txs.map(tx => tx.startsWith('0x') ? ethers.utils.keccak256(tx) : tx);
+        const concatenatedHashes = ethers.utils.concat(txHashes);
+        const messageHash = ethers.utils.keccak256(concatenatedHashes);
+        const signature = wallet._signingKey().signDigest(messageHash);
+        return signature.compact;
+    }
+
+    static verify48SPSignature(signature: string, txs: string[], expectedSignerAddress: string): boolean {
+        try {
+            const txHashes = txs.map(tx => tx.startsWith('0x') ? ethers.utils.keccak256(tx) : tx);
+            const concatenatedHashes = ethers.utils.concat(txHashes);
+            const messageHash = ethers.utils.keccak256(concatenatedHashes);
+            const recoveredAddress = ethers.utils.recoverAddress(messageHash, signature);
+            return recoveredAddress.toLowerCase() === expectedSignerAddress.toLowerCase();
+        } catch {
+            return false;
+        }
+    }
+}

package/src/_48club/ws.ts

@@ -0,0 +1,47 @@
+import { log_info, log_warn, WebSocketClient } from '@clonegod/ttd-core';
+import { BscSendTxRequestType } from '../types';
+
+/**
+ * 48Club WebSocket 发送器（长连接发送 bundle 到 builder）
+ */
+export class _48ClubWsSender {
+    private wsClient: WebSocketClient | null = null;
+    private wsUrl: string;
+
+    constructor() {
+        this.wsUrl = process.env._48CLUB_WS_URL || 'wss://puissant-builder.48.club/';
+    }
+
+    connect(): void {
+        if (this.wsClient?.isConnected()) return;
+        if (this.wsClient) { this.wsClient.disconnect(); this.wsClient = null; }
+
+        this.wsClient = new WebSocketClient(this.wsUrl, { reconnectInterval: 1000 });
+        this.wsClient.onOpen(() => log_info(`[48club-ws] connected`));
+        this.wsClient.onMessage((msg: any) => log_info(`[48club-ws] response:`, msg));
+        this.wsClient.connect();
+    }
+
+    isConnected(): boolean {
+        return this.wsClient?.isConnected() || false;
+    }
+
+    async sendTransaction(request: BscSendTxRequestType): Promise<void> {
+        if (!this.isConnected()) { log_warn('[48club-ws] not connected'); return; }
+        if (!request.tipTx) { log_warn('[48club-ws] tipTx required for bundle'); return; }
+
+        const currentTimestamp = Math.floor(Date.now() / 1000);
+        const bundleParams: any = {
+            txs: [request.mainTx, request.tipTx],
+            maxTimestamp: currentTimestamp + 2,
+        };
+        if (request.blockNumber > 0) bundleParams.maxBlockNumber = request.blockNumber + 2;
+        if (request._48spSign) bundleParams['48spSign'] = request._48spSign;
+
+        this.wsClient!.send(JSON.stringify({
+            jsonrpc: '2.0', id: '1',
+            method: 'eth_sendBundle',
+            params: [bundleParams]
+        }));
+    }
+}

package/src/blockrazor/index.ts

@@ -0,0 +1,57 @@
+import { log_error } from '@clonegod/ttd-core';
+import axios from 'axios';
+
+/**
+ * BlockRazor HTTP API
+ * https://blockrazor.gitbook.io/blockrazor/bsc/block-builder
+ */
+export class BlockRazorTrade {
+    private rpcUrl: string;
+    private authToken: string;
+
+    constructor() {
+        this.rpcUrl = process.env.BLOCKRAZOR_RPC_URL || 'https://rpc.blockrazor.builders';
+        this.authToken = process.env.BLOCKRAZOR_AUTH_TOKEN || '';
+    }
+
+    async sendPrivateTransaction(signedTx: string): Promise<string> {
+        try {
+            const response = await axios.post(this.rpcUrl, {
+                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}`);
+            }
+            return response.data.result;
+        } catch (error: any) {
+            log_error('blockrazor sendPrivateTransaction failed', error);
+            throw error;
+        }
+    }
+
+    async sendBundle(transactions: string[]): Promise<string> {
+        try {
+            const currentTimestamp = Math.floor(Date.now() / 1000);
+            const response = await axios.post(this.rpcUrl, {
+                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}`);
+            }
+            return response.data.result;
+        } catch (error: any) {
+            log_error('blockrazor sendBundle failed', error);
+            throw error;
+        }
+    }
+}

package/src/bloxroute/index.ts

@@ -0,0 +1 @@
+export { BloXRouteWsSender } from './ws';

package/src/bloxroute/ws.ts

@@ -0,0 +1,53 @@
+import { log_info, log_warn, WebSocketClient } from '@clonegod/ttd-core';
+import { BscSendTxRequestType } from '../types';
+
+/**
+ * BloXRoute WebSocket 发送器（长连接发送 bundle 到 builder）
+ * https://docs.bloxroute.com/bsc-and-eth/apis/transaction-bundles
+ */
+export class BloXRouteWsSender {
+    private wsClient: WebSocketClient | null = null;
+    private wsUrl: string;
+    private authToken: string;
+
+    constructor() {
+        this.wsUrl = process.env.BLOXROUTE_WS_URL || 'wss://api.blxrbdn.com/ws';
+        this.authToken = process.env.BLOX_AUTH_KEY || '';
+    }
+
+    connect(): void {
+        if (this.wsClient?.isConnected()) return;
+        if (this.wsClient) { this.wsClient.disconnect(); this.wsClient = null; }
+
+        const headers: { [key: string]: string } = {};
+        if (this.authToken) headers['Authorization'] = this.authToken;
+
+        this.wsClient = new WebSocketClient(this.wsUrl, { headers, reconnectInterval: 1000 });
+        this.wsClient.onOpen(() => log_info(`[bloxroute-ws] connected`));
+        this.wsClient.onMessage((msg: any) => log_info(`[bloxroute-ws] response:`, msg));
+        this.wsClient.connect();
+    }
+
+    isConnected(): boolean {
+        return this.wsClient?.isConnected() || false;
+    }
+
+    async sendTransaction(request: BscSendTxRequestType): Promise<void> {
+        if (!this.isConnected()) { log_warn('[bloxroute-ws] not connected'); return; }
+        if (!request.tipTx) { log_warn('[bloxroute-ws] tipTx required for bundle'); return; }
+
+        const targetBlockNumber = request.blockNumber + 4;
+
+        this.wsClient!.send(JSON.stringify({
+            id: "1",
+            method: "blxr_submit_bundle",
+            params: {
+                transaction: [request.mainTx, request.tipTx],
+                blockchain_network: "BSC-Mainnet",
+                block_number: `0x${targetBlockNumber.toString(16)}`,
+                max_timestamp: Math.floor(Date.now() / 1000) + 2,
+                mev_builders: { "all": "" }
+            }
+        }));
+    }
+}

package/src/constants.ts

@@ -0,0 +1,5 @@
+export enum BSC_EOA_ADDRESS {
+    BLOCKRAZOR = '0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20',
+    _48CLUB = '0x4848489f0b2BEdd788c696e2D79b6b69D7484848',
+    BLXR = '0x74c5F8C6ffe41AD4789602BDB9a48E6Cad623520',
+}

package/src/index.ts

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

package/src/rpc/index.ts

@@ -0,0 +1,42 @@
+import { log_warn } from '@clonegod/ttd-core';
+
+export class BscMainnetRpc {
+    private url: string;
+    private headers: Headers;
+
+    constructor(rpc_endpoint: string) {
+        this.url = rpc_endpoint || process.env.BSC_RPC_ENDPOINT || '';
+        this.headers = new Headers();
+        this.headers.append("Content-Type", "application/json");
+    }
+
+    async eth_sendRawTransaction(signedTx: string): Promise<string> {
+        setTimeout(async () => {
+            console.log(`Sending transaction to ${this.url}`);
+
+            const raw = JSON.stringify({
+                jsonrpc: "2.0",
+                method: "eth_sendRawTransaction",
+                params: [signedTx],
+                id: 1
+            });
+
+            const requestOptions = {
+                method: 'POST',
+                headers: this.headers,
+                body: raw,
+                redirect: 'follow' as const
+            };
+
+            const response = await fetch(this.url, requestOptions);
+            const result = await response.json();
+
+            if (result.error) {
+                log_warn(result.error.message);
+            }
+            return result.result;
+        }, 0);
+
+        return '';
+    }
+}