@clonegod/ttd-bsc-common 3.1.83 → 3.1.88

package/dist/trade/abstract_dex_trade_plus.js

@@ -0,0 +1,227 @@
+"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.AbstractEvmDexTradePlus = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_1 = require("ethers");
+const common_1 = require("../common");
+class AbstractEvmDexTradePlus extends dist_1.AbastrcatTrade {
+    constructor(appConfig) {
+        super();
+        this.appConfig = appConfig;
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.initConfigs();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
+            if (!process.env.WALLET_GROUP_IDS) {
+                throw new Error('必须配置 WALLET_GROUP_IDS 环境变量来启用多钱包功能');
+            }
+            let wallet_infos = (0, dist_1.load_wallet_multi)(((_a = process.env.WALLET_GROUP_IDS) === null || _a === void 0 ? void 0 : _a.split(',')) || [], false);
+            this.group_wallets = wallet_infos.map(info => new ethers_1.ethers.Wallet(info.private_key, this.provider));
+            (0, dist_1.log_info)(`组钱包已初始化，数量: ${this.group_wallets.length}`, this.group_wallets.map(e => e.address));
+            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.provider);
+            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}, 钱包数量: ${this.group_wallets.length}`);
+        });
+    }
+    getTokenContract(tokenAddress) {
+        if (!this.tokenContracts.has(tokenAddress)) {
+            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.provider);
+            this.tokenContracts.set(tokenAddress, tokenContract);
+        }
+        return this.tokenContracts.get(tokenAddress);
+    }
+    getTokenContractWithWallet(tokenAddress, wallet) {
+        const tokenContract = this.getTokenContract(tokenAddress);
+        return tokenContract.connect(wallet);
+    }
+    getGasPriceGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_gas_price_gwei === undefined || evm_gas_price_gwei === null || evm_gas_price_gwei <= 0) {
+            evm_gas_price_gwei = this.chainConfig.gasOptions.defaultGasPriceGwei;
+        }
+        (0, dist_1.log_info)(`getGasPriceGwei: ${evm_gas_price_gwei} Gwei`);
+        return evm_gas_price_gwei.toString();
+    }
+    getBuilderTipAmoutGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_tip_amount_gwei === undefined || evm_tip_amount_gwei === null || evm_tip_amount_gwei <= 0) {
+            evm_tip_amount_gwei = this.chainConfig.gasOptions.defaultTipAmountGwei;
+        }
+        (0, dist_1.log_info)(`getGasTipAmoutGwei: ${evm_tip_amount_gwei} Gwei`);
+        return evm_tip_amount_gwei.toString();
+    }
+    preApproveAllWallets() {
+        return __awaiter(this, arguments, void 0, function* (token_list = []) {
+            if (!this.group_wallets || this.group_wallets.length === 0) {
+                (0, dist_1.log_info)('No wallets available for pre-approval');
+                return;
+            }
+            if (!token_list || token_list.length === 0) {
+                token_list = Array.from(this.tokenContracts.keys());
+            }
+            (0, dist_1.log_info)(`Pre-approve: ${this.group_wallets.length} wallets, ${token_list.length} tokens`, token_list);
+            const tokenAddresses = new Set();
+            for (const token_address of token_list) {
+                tokenAddresses.add(token_address.toLowerCase());
+            }
+            const tokens = Array.from(tokenAddresses);
+            for (const wallet of this.group_wallets) {
+                try {
+                    (0, dist_1.log_info)(`Pre-approve: wallet ${wallet.address}`);
+                    for (const tokenAddress of tokens) {
+                        try {
+                            yield this.approveTokenIfNeeded(wallet, tokenAddress);
+                        }
+                        catch (error) {
+                            console.warn(`Failed to pre-approve token ${tokenAddress} for wallet ${wallet.address}:`, error);
+                        }
+                    }
+                    (0, dist_1.log_info)(`Pre-approve: wallet ${wallet.address} completed`);
+                }
+                catch (error) {
+                    console.warn(`Failed to pre-approve tokens for wallet ${wallet.address}:`, error);
+                }
+            }
+            (0, dist_1.log_info)('Pre-approve: all wallets completed');
+        });
+    }
+    approveTokenIfNeeded(wallet, tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenContract = this.getTokenContract(tokenAddress);
+                const routerAddress = this.dexConfig.routerAddress;
+                const currentAllowance = yield tokenContract.allowance(wallet.address, routerAddress);
+                if (currentAllowance.gt(0)) {
+                    (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} already approved`);
+                    return;
+                }
+                const maxAllowance = ethers_1.ethers.constants.MaxUint256;
+                const approveTx = yield tokenContract.connect(wallet).approve(routerAddress, maxAllowance);
+                (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} approve success, tx: ${approveTx.hash}`);
+                yield approveTx.wait();
+                (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} approved successfully`);
+            }
+            catch (error) {
+                console.warn(`Failed to approve token ${tokenAddress} for wallet ${wallet.address}:`, error);
+                throw error;
+            }
+        });
+    }
+    checkTradeTokenApprove(context, wallet, routerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pool_info } = context;
+            const { tokenA, tokenB } = pool_info;
+            const router = routerAddress || this.dexConfig.routerAddress;
+            if (!this.approvedTokens.has(wallet.address)) {
+                this.approvedTokens.set(wallet.address, new Map());
+            }
+            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
+                const tokenContract = this.getTokenContractWithWallet(address, wallet);
+                yield this.checkTokenApprove(address, symbol, tokenContract, router, wallet);
+            })));
+        });
+    }
+    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress, wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.approvedTokens.has(wallet.address)) {
+                this.approvedTokens.set(wallet.address, new Map());
+            }
+            if (this.approvedTokens.get(wallet.address).get(tokenAddress)) {
+                (0, dist_1.log_info)(`钱包 ${wallet.address} 的代币 ${tokenSymbol} 已授权，跳过授权检查`);
+                return true;
+            }
+            const allowance = yield tokenContract.allowance(wallet.address, spenderAddress);
+            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
+            (0, dist_1.log_info)(`代币授权检查:`, {
+                walletAddress: wallet.address,
+                tokenSymbol,
+                currentAllowance: allowance.toString(),
+                maxAllowance: maxAllowance.toString(),
+                isSufficient: allowance.gte(maxAllowance)
+            });
+            if (allowance.lt(maxAllowance)) {
+                const maxApprovalAmount = ethers_1.ethers.utils.formatUnits(ethers_1.ethers.constants.MaxUint256, yield tokenContract.decimals());
+                const tokenSymbolDisplay = tokenSymbol || `${tokenAddress.substring(0, 6)}...`;
+                (0, dist_1.log_info)(`正在为钱包 ${wallet.address} 授权代币 ${tokenSymbolDisplay}`, {
+                    walletAddress: wallet.address,
+                    tokenAddress,
+                    tokenSymbol: tokenSymbolDisplay,
+                    currentAllowance: ethers_1.ethers.utils.formatUnits(allowance, yield tokenContract.decimals()),
+                    newAllowance: maxApprovalAmount
+                });
+                const tx = yield tokenContract.approve(spenderAddress, ethers_1.ethers.constants.MaxUint256, {
+                    gasLimit: this.chainConfig.gasOptions.gasLimit
+                });
+                yield tx.wait();
+                this.approvedTokens.get(wallet.address).set(tokenAddress, true);
+                (0, dist_1.log_info)(`钱包 ${wallet.address} 的代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
+                return true;
+            }
+            else {
+                this.approvedTokens.get(wallet.address).set(tokenAddress, true);
+                return true;
+            }
+        });
+    }
+    isNonceRelatedError(error) {
+        if (!error)
+            return false;
+        const errorMessage = error.message ? error.message.toLowerCase() : '';
+        const nonceErrorKeywords = [
+            'nonce',
+            'nonce too low',
+            'nonce too high',
+            'nonce has already been used',
+            'already known',
+            'replacement transaction underpriced',
+            'transaction with same nonce',
+            'transaction nonce is too low',
+            'invalid transaction nonce',
+            'insufficient funds',
+            'sign bundle to get failure details',
+        ];
+        return nonceErrorKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    isNativeCurrency(symbol) {
+        return symbol.toUpperCase() === this.chainConfig.nativeCurrency;
+    }
+    getWrappedNativeAddress() {
+        return this.chainConfig.wrappedNativeCurrencyAddress;
+    }
+    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, transfer_nonce, wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
+            let real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+            let tx_data = {
+                from: wallet.address,
+                to,
+                value: ethers_1.ethers.utils.parseUnits(real_transfer_amount_gwei, 'gwei'),
+                gasLimit: 21000,
+                gasPrice: ethers_1.ethers.utils.parseUnits(real_gas_price_gwei, 'gwei'),
+                nonce: transfer_nonce,
+                chainId: this.chainConfig.chainId
+            };
+            let signedTx = yield wallet.signTransaction(tx_data);
+            (0, dist_1.log_info)(`构建转账交易: `, Object.assign(Object.assign({}, tx_data), { real_transfer_amount_gwei,
+                real_gas_price_gwei, txhash: ethers_1.ethers.utils.keccak256(signedTx) }));
+            return signedTx;
+        });
+    }
+}
+exports.AbstractEvmDexTradePlus = AbstractEvmDexTradePlus;

package/dist/trade/check/tx_websocket_manager.d.ts

@@ -0,0 +1,23 @@
+import { ethers } from 'ethers';
+export declare class WebSocketManager {
+    private static instance;
+    private wsProvider;
+    private wsConnections;
+    private reconnectAttempts;
+    private readonly MAX_RECONNECT_ATTEMPTS;
+    private readonly RECONNECT_DELAY;
+    private reconnecting;
+    private eventListeners;
+    private constructor();
+    static getInstance(): WebSocketManager;
+    getWsProvider(wsEndpoint: string, network: {
+        name: string;
+        chainId: number;
+    }): ethers.providers.WebSocketProvider | null;
+    private handleWsError;
+    private handleWsDisconnection;
+    incrementConnections(): void;
+    decrementConnections(): void;
+    listenToEvent(eventName: string, handler: Function): void;
+    removeEventListener(eventName: string, handler: Function): void;
+}

package/dist/trade/check/tx_websocket_manager.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketManager = void 0;
+const ethers_1 = require("ethers");
+const dist_1 = require("@clonegod/ttd-core/dist");
+class WebSocketManager {
+    constructor() {
+        this.wsProvider = null;
+        this.wsConnections = 0;
+        this.reconnectAttempts = 0;
+        this.MAX_RECONNECT_ATTEMPTS = 5;
+        this.RECONNECT_DELAY = 2000;
+        this.reconnecting = false;
+        this.eventListeners = new Map();
+    }
+    static getInstance() {
+        if (!WebSocketManager.instance) {
+            WebSocketManager.instance = new WebSocketManager();
+        }
+        return WebSocketManager.instance;
+    }
+    getWsProvider(wsEndpoint, network) {
+        if (!wsEndpoint) {
+            (0, dist_1.log_warn)('WebSocket endpoint not configured');
+            return null;
+        }
+        if (!this.wsProvider && !this.reconnecting) {
+            (0, dist_1.log_info)('Creating new WebSocket provider');
+            try {
+                this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(wsEndpoint, network);
+                this.wsProvider.on('error', (error) => {
+                    this.handleWsError(error, wsEndpoint, network);
+                });
+                this.wsProvider._websocket.on('close', () => {
+                    (0, dist_1.log_warn)('WebSocket connection closed');
+                    this.handleWsDisconnection(wsEndpoint, network);
+                });
+                this.reconnectAttempts = 0;
+            }
+            catch (error) {
+                (0, dist_1.log_error)('Failed to create WebSocket provider', error);
+                this.wsProvider = null;
+            }
+        }
+        return this.wsProvider;
+    }
+    handleWsError(error, wsEndpoint, network) {
+        (0, dist_1.log_error)('WebSocket provider error', error);
+        this.handleWsDisconnection(wsEndpoint, network);
+    }
+    handleWsDisconnection(wsEndpoint, network) {
+        if (this.reconnecting)
+            return;
+        if (this.wsProvider) {
+            this.wsProvider.removeAllListeners();
+            this.wsProvider = null;
+        }
+        if (this.wsConnections > 0 &&
+            this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
+            this.reconnecting = true;
+            this.reconnectAttempts++;
+            (0, dist_1.log_info)(`Attempting to reconnect WebSocket (${this.reconnectAttempts}/${this.MAX_RECONNECT_ATTEMPTS})`);
+            setTimeout(() => {
+                this.reconnecting = false;
+                this.getWsProvider(wsEndpoint, network);
+            }, this.RECONNECT_DELAY * this.reconnectAttempts);
+        }
+        else if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
+            (0, dist_1.log_error)(`Maximum WebSocket reconnection attempts (${this.MAX_RECONNECT_ATTEMPTS}) reached`, new Error('Max reconnect attempts'));
+            this.wsConnections = 0;
+            this.reconnectAttempts = 0;
+            this.reconnecting = false;
+        }
+    }
+    incrementConnections() {
+        this.wsConnections++;
+        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+    }
+    decrementConnections() {
+        if (this.wsConnections > 0) {
+            this.wsConnections--;
+        }
+        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        if (this.wsConnections === 0 && this.wsProvider) {
+            (0, dist_1.log_info)('No active connections, closing WebSocket');
+            this.wsProvider.removeAllListeners();
+            this.wsProvider = null;
+            this.reconnectAttempts = 0;
+        }
+    }
+    listenToEvent(eventName, handler) {
+        var _a;
+        if (!this.wsProvider) {
+            (0, dist_1.log_warn)('WebSocket provider not available for event listener');
+            return;
+        }
+        if (!this.eventListeners.has(eventName)) {
+            this.eventListeners.set(eventName, new Set());
+        }
+        (_a = this.eventListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.add(handler);
+        this.wsProvider.once(eventName, handler);
+        this.incrementConnections();
+    }
+    removeEventListener(eventName, handler) {
+        if (!this.wsProvider)
+            return;
+        this.wsProvider.removeListener(eventName, handler);
+        const handlers = this.eventListeners.get(eventName);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.eventListeners.delete(eventName);
+            }
+        }
+        this.decrementConnections();
+    }
+}
+exports.WebSocketManager = WebSocketManager;
+WebSocketManager.instance = null;

package/dist/trade/send/48club.d.ts

@@ -0,0 +1,18 @@
+export declare const _48CLUB_BUILDER_CONTROL_EOA = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848";
+export interface BundleParams {
+    txs: string[];
+    maxBlockNumber?: number;
+    maxTimestamp?: number;
+    revertingTxHashes?: string[];
+    noMerge?: boolean;
+    backrunTarget?: string;
+}
+export declare class _48ClubTrade {
+    private rpcUrl;
+    private soulPointSignature?;
+    private provider;
+    constructor(soulPointSignature?: string);
+    sendPrivateTransaction(signedTx: string): Promise<string>;
+    _sendPrivateTransactionWith48SP(signedTx: string): Promise<string>;
+    sendBundle(params: BundleParams): Promise<string>;
+}

package/dist/trade/send/48club.js

@@ -0,0 +1,97 @@
+"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 = exports._48CLUB_BUILDER_CONTROL_EOA = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+exports._48CLUB_BUILDER_CONTROL_EOA = '0x4848489f0b2BEdd788c696e2D79b6b69D7484848';
+class _48ClubTrade {
+    constructor(soulPointSignature) {
+        this.rpcUrl = process.env._48CLUB_RPC_URL || 'https://puissant-builder.48.club/';
+        this.soulPointSignature = soulPointSignature;
+        this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.rpcUrl);
+    }
+    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_sendRawTransaction",
+                    params: [signedTx]
+                });
+                if (response.data.error) {
+                    throw new Error(`RPC Error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`48club sendPrivateTransaction failed!!! ${error.message}`);
+                }
+                throw new Error('48club sendPrivateTransaction failed!!! Unknown error');
+            }
+        });
+    }
+    _sendPrivateTransactionWith48SP(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.soulPointSignature) {
+                    throw new Error('48 SoulPoint signature is required');
+                }
+                const response = yield axios_1.default.post(this.rpcUrl, {
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "eth_sendPrivateTransactionWith48SP",
+                    params: [signedTx, this.soulPointSignature]
+                });
+                if (response.data.error) {
+                    throw new Error(`RPC Error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`48club sendPrivateTransactionWith48SP failed!!! ${error.message}`);
+                }
+                throw new Error('48club sendPrivateTransactionWith48SP failed!!! Unknown error');
+            }
+        });
+    }
+    sendBundle(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentTimestamp = Math.floor(Date.now() / 1000);
+                const requestParams = Object.assign({ txs: params.txs, maxBlockNumber: params.maxBlockNumber, maxTimestamp: params.maxTimestamp || currentTimestamp + 30, revertingTxHashes: params.revertingTxHashes, noMerge: params.noMerge, backrunTarget: params.backrunTarget }, (this.soulPointSignature ? { '48spSign': this.soulPointSignature } : {}));
+                const response = yield axios_1.default.post(this.rpcUrl, {
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "eth_sendBundle",
+                    params: [requestParams]
+                });
+                if (response.data.error) {
+                    throw new Error(`RPC Error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`48club sendBundle failed!!! ${error.message}`);
+                }
+                throw new Error('48club sendBundle failed!!! Unknown error');
+            }
+        });
+    }
+}
+exports._48ClubTrade = _48ClubTrade;

package/dist/trade/send/blockrazor.d.ts

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

package/dist/trade/send/blockrazor.js

@@ -0,0 +1,79 @@
+"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 dist_1 = require("@clonegod/ttd-core/dist");
+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, dist_1.log_error)('blockrazor sendPrivateTransaction failed!!!', error);
+                throw error;
+            }
+        });
+    }
+    sendBundle(transactions, maxBlockNumber, revertingTxHashes) {
+        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,
+                            minTimestamp: currentTimestamp + 1,
+                            maxTimestamp: currentTimestamp + 30,
+                        }]
+                }, {
+                    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, dist_1.log_error)('blockrazor sendBundle failed!!!', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.BlockRazorTrade = BlockRazorTrade;

package/dist/trade/send/bsc_rpc.d.ts

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

package/dist/trade/send/bsc_rpc.js

@@ -0,0 +1,43 @@
+"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.BscRpc = void 0;
+class BscRpc {
+    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* () {
+            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) {
+                throw new Error(result.error.message);
+            }
+            return result.result;
+        });
+    }
+}
+exports.BscRpc = BscRpc;

package/dist/trade/send/index.d.ts

@@ -0,0 +1,5 @@
+export * from './send_tx';
+export declare enum BSC_EOA_ADDRESS {
+    BLOCKRAZOR = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20",
+    _48CLUB = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848"
+}

package/dist/trade/send/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSC_EOA_ADDRESS = void 0;
+__exportStar(require("./send_tx"), exports);
+var BSC_EOA_ADDRESS;
+(function (BSC_EOA_ADDRESS) {
+    BSC_EOA_ADDRESS["BLOCKRAZOR"] = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20";
+    BSC_EOA_ADDRESS["_48CLUB"] = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848";
+})(BSC_EOA_ADDRESS || (exports.BSC_EOA_ADDRESS = BSC_EOA_ADDRESS = {}));

package/dist/trade/send/send_tx.d.ts

@@ -0,0 +1,8 @@
+import { AppConfig } from "@clonegod/ttd-core/dist";
+export declare class TransactionSender {
+    private rpc;
+    private blockRazor;
+    private _48Club;
+    constructor(appConfig: AppConfig);
+    sendTransaction(signedMainTx: string, eoa_tip_transaction: (eoa_address: string) => Promise<string>, order_trace_id: string): Promise<string[]>;
+}