@clonegod/ttd-bsc-send-tx 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+## BSC - Submit tx to Builder
+
+### 48club
+> https://docs.48.club/puissant-builder/send-privatetransaction
+> https://docs.48.club/puissant-builder/send-bundle
+
+#### Endpoint
+- https://puissant-builder.48.club/
+- wss://puissant-builder.48.club/
+
+#### EOA address
+0x4848489f0b2BEdd788c696e2D79b6b69D7484848
+
+
+
+### BlockRazor
+> https://blockrazor.gitbook.io/blockrazor/tc/bsc/block-builder/send-privatetransaction
+> https://blockrazor.gitbook.io/blockrazor/tc/bsc/block-builder/send-bundle
+
+#### Endpoint
+- https://tokyo.builder.blockrazor.io
+
+#### EOA address
+0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20
+
+
+
+### BloXRoute
+> https://docs.bloxroute.com/bsc-and-eth/apis/frontrunning-protection/bsc-private-transactions
+> https://docs.bloxroute.com/bsc-and-eth/apis/transaction-bundles/bundle-submission/bsc-bundle-submission
+
+#### Endpoint
+- https://api.blxrbdn.com
+- wss://api.blxrbdn.com/ws
+
+
+### EOA address
+0x6374Ca2da5646C73Eb444aB99780495d61035f9b
+
+

package/dist/_48club/http.d.ts

@@ -0,0 +1,9 @@
+export declare class _48ClubTrade {
+    private rpcUrl;
+    constructor();
+    sendPrivateTransactionWith48SP(signedTx: string): Promise<string>;
+    sendBundle(params: {
+        txs: string[];
+    }): Promise<string>;
+    get48SPSignature(txs: string[]): Promise<string>;
+}

package/dist/_48club/http.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._48ClubTrade = void 0;
+const axios_1 = __importDefault(require("axios"));
+const sp_signature_1 = require("./sp_signature");
+const member_1 = require("./member");
+class _48ClubTrade {
+    constructor() {
+        this.rpcUrl = process.env._48CLUB_RPC_URL || 'https://puissant-bsc.48.club';
+    }
+    sendPrivateTransactionWith48SP(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spSign = yield this.get48SPSignature([signedTx]);
+            const response = yield axios_1.default.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;
+        });
+    }
+    sendBundle(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTimestamp = Math.floor(Date.now() / 1000);
+            const spSign = yield this.get48SPSignature(params.txs);
+            const response = yield axios_1.default.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;
+        });
+    }
+    get48SPSignature(txs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const privateKey = (0, member_1.get_48club_sp_private_key)();
+            if (!privateKey)
+                return '';
+            return sp_signature_1.SoulPointSignature.generate48SPSignature(privateKey, txs);
+        });
+    }
+}
+exports._48ClubTrade = _48ClubTrade;

package/dist/_48club/index.d.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/dist/_48club/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_48club_sp_private_key = exports.SoulPointSignature = exports._48ClubWsSender = exports._48ClubTrade = void 0;
+var http_1 = require("./http");
+Object.defineProperty(exports, "_48ClubTrade", { enumerable: true, get: function () { return http_1._48ClubTrade; } });
+var ws_1 = require("./ws");
+Object.defineProperty(exports, "_48ClubWsSender", { enumerable: true, get: function () { return ws_1._48ClubWsSender; } });
+var sp_signature_1 = require("./sp_signature");
+Object.defineProperty(exports, "SoulPointSignature", { enumerable: true, get: function () { return sp_signature_1.SoulPointSignature; } });
+var member_1 = require("./member");
+Object.defineProperty(exports, "get_48club_sp_private_key", { enumerable: true, get: function () { return member_1.get_48club_sp_private_key; } });

package/dist/_48club/member.d.ts

@@ -0,0 +1 @@
+export declare const get_48club_sp_private_key: () => string | null;

package/dist/_48club/member.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_48club_sp_private_key = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+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');
+        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) {
+        console.error('Load 48club SP wallet failed:' + error.message);
+        return null;
+    }
+};
+exports.get_48club_sp_private_key = get_48club_sp_private_key;

package/dist/_48club/sp_signature.d.ts

@@ -0,0 +1,4 @@
+export declare class SoulPointSignature {
+    static generate48SPSignature(privateKey: string, txs: string[]): string;
+    static verify48SPSignature(signature: string, txs: string[], expectedSignerAddress: string): boolean;
+}

package/dist/_48club/sp_signature.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoulPointSignature = void 0;
+const ethers_1 = require("ethers");
+class SoulPointSignature {
+    static generate48SPSignature(privateKey, txs) {
+        const wallet = new ethers_1.ethers.Wallet(privateKey);
+        const txHashes = txs.map(tx => tx.startsWith('0x') ? ethers_1.ethers.utils.keccak256(tx) : tx);
+        const concatenatedHashes = ethers_1.ethers.utils.concat(txHashes);
+        const messageHash = ethers_1.ethers.utils.keccak256(concatenatedHashes);
+        const signature = wallet._signingKey().signDigest(messageHash);
+        return signature.compact;
+    }
+    static verify48SPSignature(signature, txs, expectedSignerAddress) {
+        try {
+            const txHashes = txs.map(tx => tx.startsWith('0x') ? ethers_1.ethers.utils.keccak256(tx) : tx);
+            const concatenatedHashes = ethers_1.ethers.utils.concat(txHashes);
+            const messageHash = ethers_1.ethers.utils.keccak256(concatenatedHashes);
+            const recoveredAddress = ethers_1.ethers.utils.recoverAddress(messageHash, signature);
+            return recoveredAddress.toLowerCase() === expectedSignerAddress.toLowerCase();
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.SoulPointSignature = SoulPointSignature;

package/dist/_48club/ws.d.ts

@@ -0,0 +1,9 @@
+import { BscSendTxRequestType } from '../types';
+export declare class _48ClubWsSender {
+    private wsClient;
+    private wsUrl;
+    constructor();
+    connect(): void;
+    isConnected(): boolean;
+    sendTransaction(request: BscSendTxRequestType): Promise<void>;
+}

package/dist/_48club/ws.js

@@ -0,0 +1,63 @@
+"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 });
+exports._48ClubWsSender = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+class _48ClubWsSender {
+    constructor() {
+        this.wsClient = null;
+        this.wsUrl = process.env._48CLUB_WS_URL || 'wss://puissant-builder.48.club/';
+    }
+    connect() {
+        var _a;
+        if ((_a = this.wsClient) === null || _a === void 0 ? void 0 : _a.isConnected())
+            return;
+        if (this.wsClient) {
+            this.wsClient.disconnect();
+            this.wsClient = null;
+        }
+        this.wsClient = new ttd_core_1.WebSocketClient(this.wsUrl, { reconnectInterval: 1000 });
+        this.wsClient.onOpen(() => (0, ttd_core_1.log_info)(`[48club-ws] connected`));
+        this.wsClient.onMessage((msg) => (0, ttd_core_1.log_info)(`[48club-ws] response:`, msg));
+        this.wsClient.connect();
+    }
+    isConnected() {
+        var _a;
+        return ((_a = this.wsClient) === null || _a === void 0 ? void 0 : _a.isConnected()) || false;
+    }
+    sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                (0, ttd_core_1.log_warn)('[48club-ws] not connected');
+                return;
+            }
+            if (!request.tipTx) {
+                (0, ttd_core_1.log_warn)('[48club-ws] tipTx required for bundle');
+                return;
+            }
+            const currentTimestamp = Math.floor(Date.now() / 1000);
+            const bundleParams = {
+                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]
+            }));
+        });
+    }
+}
+exports._48ClubWsSender = _48ClubWsSender;

package/dist/blockrazor/index.d.ts

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

package/dist/blockrazor/index.js

@@ -0,0 +1,67 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockRazorTrade = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const axios_1 = __importDefault(require("axios"));
+class BlockRazorTrade {
+    constructor() {
+        this.rpcUrl = process.env.BLOCKRAZOR_RPC_URL || 'https://rpc.blockrazor.builders';
+        this.authToken = process.env.BLOCKRAZOR_AUTH_TOKEN || '';
+    }
+    sendPrivateTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.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) {
+                (0, ttd_core_1.log_error)('blockrazor sendPrivateTransaction failed', error);
+                throw error;
+            }
+        });
+    }
+    sendBundle(transactions) {
+        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, {
+                    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) {
+                (0, ttd_core_1.log_error)('blockrazor sendBundle failed', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.BlockRazorTrade = BlockRazorTrade;

package/dist/bloxroute/index.d.ts

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

package/dist/bloxroute/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BloXRouteWsSender = void 0;
+var ws_1 = require("./ws");
+Object.defineProperty(exports, "BloXRouteWsSender", { enumerable: true, get: function () { return ws_1.BloXRouteWsSender; } });

package/dist/bloxroute/ws.d.ts

@@ -0,0 +1,10 @@
+import { BscSendTxRequestType } from '../types';
+export declare class BloXRouteWsSender {
+    private wsClient;
+    private wsUrl;
+    private authToken;
+    constructor();
+    connect(): void;
+    isConnected(): boolean;
+    sendTransaction(request: BscSendTxRequestType): Promise<void>;
+}

package/dist/bloxroute/ws.js

@@ -0,0 +1,65 @@
+"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 });
+exports.BloXRouteWsSender = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+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 || '';
+    }
+    connect() {
+        var _a;
+        if ((_a = this.wsClient) === null || _a === void 0 ? void 0 : _a.isConnected())
+            return;
+        if (this.wsClient) {
+            this.wsClient.disconnect();
+            this.wsClient = null;
+        }
+        const headers = {};
+        if (this.authToken)
+            headers['Authorization'] = this.authToken;
+        this.wsClient = new ttd_core_1.WebSocketClient(this.wsUrl, { headers, reconnectInterval: 1000 });
+        this.wsClient.onOpen(() => (0, ttd_core_1.log_info)(`[bloxroute-ws] connected`));
+        this.wsClient.onMessage((msg) => (0, ttd_core_1.log_info)(`[bloxroute-ws] response:`, msg));
+        this.wsClient.connect();
+    }
+    isConnected() {
+        var _a;
+        return ((_a = this.wsClient) === null || _a === void 0 ? void 0 : _a.isConnected()) || false;
+    }
+    sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                (0, ttd_core_1.log_warn)('[bloxroute-ws] not connected');
+                return;
+            }
+            if (!request.tipTx) {
+                (0, ttd_core_1.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": "" }
+                }
+            }));
+        });
+    }
+}
+exports.BloXRouteWsSender = BloXRouteWsSender;

package/dist/constants.d.ts

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

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSC_EOA_ADDRESS = void 0;
+var BSC_EOA_ADDRESS;
+(function (BSC_EOA_ADDRESS) {
+    BSC_EOA_ADDRESS["BLOCKRAZOR"] = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20";
+    BSC_EOA_ADDRESS["_48CLUB"] = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848";
+    BSC_EOA_ADDRESS["BLXR"] = "0x74c5F8C6ffe41AD4789602BDB9a48E6Cad623520";
+})(BSC_EOA_ADDRESS || (exports.BSC_EOA_ADDRESS = BSC_EOA_ADDRESS = {}));

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSC_EOA_ADDRESS = exports.TransactionSender = void 0;
+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; } });

package/dist/rpc/index.d.ts

@@ -0,0 +1,6 @@
+export declare class BscMainnetRpc {
+    private url;
+    private headers;
+    constructor(rpc_endpoint: string);
+    eth_sendRawTransaction(signedTx: string): Promise<string>;
+}

package/dist/rpc/index.js

@@ -0,0 +1,47 @@
+"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 });
+exports.BscMainnetRpc = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+class BscMainnetRpc {
+    constructor(rpc_endpoint) {
+        this.url = rpc_endpoint || process.env.BSC_RPC_ENDPOINT || '';
+        this.headers = new Headers();
+        this.headers.append("Content-Type", "application/json");
+    }
+    eth_sendRawTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                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'
+                };
+                const response = yield fetch(this.url, requestOptions);
+                const result = yield response.json();
+                if (result.error) {
+                    (0, ttd_core_1.log_warn)(result.error.message);
+                }
+                return result.result;
+            }), 0);
+            return '';
+        });
+    }
+}
+exports.BscMainnetRpc = BscMainnetRpc;

package/dist/transaction_sender.d.ts

@@ -0,0 +1,9 @@
+import { AppConfig } from '@clonegod/ttd-core';
+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[]>;
+}

package/dist/transaction_sender.js

@@ -0,0 +1,116 @@
+"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 });
+exports.TransactionSender = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const rpc_1 = require("./rpc");
+const blockrazor_1 = require("./blockrazor");
+const _48club_1 = require("./_48club");
+const ws_client_1 = require("./ws_client");
+const constants_1 = require("./constants");
+class TransactionSender {
+    constructor(appConfig) {
+        this.rpc = new rpc_1.BscMainnetRpc(appConfig.env_args.rpc_endpoint);
+        this.blockRazor = new blockrazor_1.BlockRazorTrade();
+        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 = [
+                {
+                    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',
+                    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',
+                    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);
+                    }),
+                },
+                {
+                    name: '48Club HTTP 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',
+                    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 results = [];
+            const errors = [];
+            yield Promise.all(rpcProviders
+                .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 });
+                }
+            })));
+            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;
+        });
+    }
+}
+exports.TransactionSender = TransactionSender;