@clonegod/ttd-bsc-common 1.0.0

package/dist/trade/abstract_dex_trade.js

@@ -0,0 +1,152 @@
+"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.AbstractEvmDexTrade = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_1 = require("ethers");
+const common_1 = require("../common");
+class AbstractEvmDexTrade 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* () {
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
+            this.wallet = new ethers_1.ethers.Wallet(this.appConfig.trade_runtime.wallet.private_key, this.provider);
+            (0, dist_1.log_info)(`钱包已初始化，地址: ${this.wallet.address}`);
+            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.wallet);
+            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}`);
+        });
+    }
+    getTokenContract(tokenAddress) {
+        if (!this.tokenContracts.has(tokenAddress)) {
+            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.wallet);
+            this.tokenContracts.set(tokenAddress, tokenContract);
+        }
+        return this.tokenContracts.get(tokenAddress);
+    }
+    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();
+    }
+    checkTradeTokenApprove(context, routerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pool_info } = context;
+            const { tokenA, tokenB } = pool_info;
+            const router = routerAddress || this.dexConfig.routerAddress;
+            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
+                const tokenContract = this.getTokenContract(address);
+                yield this.checkTokenApprove(address, symbol, tokenContract, router);
+            })));
+        });
+    }
+    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.approvedTokens.get(tokenAddress)) {
+                (0, dist_1.log_info)(`代币 ${tokenSymbol} 已授权，跳过授权检查`);
+                return true;
+            }
+            const allowance = yield tokenContract.allowance(this.wallet.address, spenderAddress);
+            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
+            (0, dist_1.log_info)(`代币授权检查:`, {
+                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)(`正在为合约授权代币 ${tokenSymbolDisplay}`, {
+                    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.set(tokenAddress, true);
+                (0, dist_1.log_info)(`代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
+                return true;
+            }
+            else {
+                this.approvedTokens.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',
+        ];
+        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) {
+        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: this.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 this.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.AbstractEvmDexTrade = AbstractEvmDexTrade;

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

@@ -0,0 +1 @@
+export * from "./tx_websocket_manager";

package/dist/trade/check/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./tx_websocket_manager"), exports);

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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './send';
+export * from './parse';
+export * from './check';
+export * from './abstract_dex_trade';

package/dist/trade/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./send"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./abstract_dex_trade"), exports);

package/dist/trade/parse/abstract_parser.d.ts

@@ -0,0 +1,8 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from '@clonegod/ttd-core';
+import { TransactionReceipt } from '@ethersproject/providers';
+export interface ITxParser {
+    parseTransaction(txReceipt: TransactionReceipt, poolInfo: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+}
+export interface ITxParserFactory {
+    createParser(version: string): ITxParser;
+}

package/dist/trade/parse/abstract_parser.js

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

package/dist/trade/parse/base_parser.d.ts

@@ -0,0 +1,30 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from "@clonegod/ttd-core";
+import { TransactionReceipt } from '@ethersproject/providers';
+import { ethers } from 'ethers';
+import { ITxParser } from "./abstract_parser";
+import { ParserConfig } from "../../types";
+export declare abstract class BaseTxParser implements ITxParser {
+    protected config: ParserConfig;
+    protected provider: ethers.providers.JsonRpcProvider;
+    protected blockTimeCache: Map<number, number>;
+    protected readonly CACHE_EXPIRY: number;
+    constructor(config: ParserConfig);
+    abstract parseTransaction(txReceipt: TransactionReceipt, poolInfo: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+    protected getBlockTime(blockNumber: number): Promise<number>;
+    protected calculateGasFee(txReceipt: TransactionReceipt): {
+        base_fee: number;
+        priority_fee: number;
+        total_fee: number;
+    };
+    protected parseClmmSwapEvent(logs: any[], poolAddress: string): {
+        amount0: ethers.BigNumber;
+        amount1: ethers.BigNumber;
+        sqrtPriceX96: ethers.BigNumber;
+        liquidity: ethers.BigNumber;
+        tick: number;
+        protocolFeesToken0: ethers.BigNumber;
+        protocolFeesToken1: ethers.BigNumber;
+        sender?: string;
+        recipient?: string;
+    };
+}

package/dist/trade/parse/base_parser.js

@@ -0,0 +1,108 @@
+"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.BaseTxParser = void 0;
+const ethers_1 = require("ethers");
+class BaseTxParser {
+    constructor(config) {
+        this.blockTimeCache = new Map();
+        this.CACHE_EXPIRY = 1000 * 60 * 60;
+        this.config = config;
+        this.provider = new ethers_1.ethers.providers.JsonRpcProvider(config.rpcEndpoint);
+    }
+    getBlockTime(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (process.env.NEED_BLOCK_TIME_INFO !== 'true') {
+                return 0;
+            }
+            try {
+                if (this.blockTimeCache.has(blockNumber)) {
+                    return this.blockTimeCache.get(blockNumber);
+                }
+                const block = yield this.provider.getBlock(blockNumber);
+                const timestamp = block.timestamp * 1000;
+                this.blockTimeCache.set(blockNumber, timestamp);
+                setTimeout(() => {
+                    this.blockTimeCache.delete(blockNumber);
+                }, this.CACHE_EXPIRY);
+                return timestamp;
+            }
+            catch (error) {
+                console.error('获取区块时间失败:', error);
+                return 0;
+            }
+        });
+    }
+    calculateGasFee(txReceipt) {
+        try {
+            const gasUsed = txReceipt.gasUsed || ethers_1.ethers.BigNumber.from(0);
+            const effectiveGasPrice = txReceipt.effectiveGasPrice || ethers_1.ethers.BigNumber.from(0);
+            const totalFeeBN = gasUsed.mul(effectiveGasPrice);
+            const totalFee = Number(ethers_1.ethers.utils.formatEther(totalFeeBN));
+            return {
+                base_fee: 0,
+                priority_fee: totalFee,
+                total_fee: totalFee
+            };
+        }
+        catch (error) {
+            console.error('计算 gas 费用失败:', error);
+            return {
+                base_fee: 0,
+                priority_fee: 0,
+                total_fee: 0
+            };
+        }
+    }
+    parseClmmSwapEvent(logs, poolAddress) {
+        const swapEventTopic = '0x19b47279256b2a23a1665c810c8d55a1758940ee09377d4f8d26497a3577dc83';
+        const swapLog = logs.find(log => log.address.toLowerCase() === poolAddress.toLowerCase() &&
+            log.topics[0].toLowerCase() === swapEventTopic.toLowerCase());
+        if (!swapLog) {
+            console.error('找不到Swap事件，所有日志:', logs.map(l => ({
+                address: l.address,
+                topics: l.topics
+            })));
+            throw new Error(`找不到池子 ${poolAddress} 的Swap事件`);
+        }
+        try {
+            const decodedData = ethers_1.ethers.utils.defaultAbiCoder.decode(['int256', 'int256', 'uint160', 'uint128', 'int24', 'uint128', 'uint128'], swapLog.data);
+            let sender = undefined;
+            let recipient = undefined;
+            if (swapLog.topics.length > 1) {
+                sender = ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], ethers_1.ethers.utils.hexZeroPad(swapLog.topics[1], 32))[0];
+            }
+            if (swapLog.topics.length > 2) {
+                recipient = ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], ethers_1.ethers.utils.hexZeroPad(swapLog.topics[2], 32))[0];
+            }
+            const [amount0, amount1, sqrtPriceX96, liquidity, tick, protocolFeesToken0, protocolFeesToken1] = decodedData;
+            return {
+                amount0,
+                amount1,
+                sqrtPriceX96,
+                liquidity,
+                tick,
+                protocolFeesToken0,
+                protocolFeesToken1,
+                sender,
+                recipient
+            };
+        }
+        catch (error) {
+            console.error('解析Swap事件失败:', error, {
+                logData: swapLog ? swapLog.data : 'No log',
+                logTopics: swapLog ? swapLog.topics : 'No log'
+            });
+            throw new Error(`解析Swap事件失败: ${error.message}`);
+        }
+    }
+}
+exports.BaseTxParser = BaseTxParser;

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

@@ -0,0 +1 @@
+export { BaseTxParser } from './base_parser';

package/dist/trade/parse/index.js

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

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>;
+}