four-flap-meme-sdk 1.9.49 → 2.1.0

package/dist/chains/bsc/four/submit/blockrazor.d.ts

@@ -1,18 +0,0 @@
-import type { BlockRazorSubmitConfig, BlockRazorSubmitResult } from './types.js';
-export declare function submitBundleToBlockRazor(signedTransactions: string[], config: BlockRazorSubmitConfig): Promise<BlockRazorSubmitResult>;
-/**
- * 批量提交多个 Bundle 到 BlockRazor（顺序执行）
- *
- * @param bundles 多个 Bundle 的签名交易数组
- * @param config BlockRazor 提交配置
- * @returns Bundle 提交结果数组
- */
-export declare function submitMultipleBundlesToBlockRazor(bundles: string[][], config: BlockRazorSubmitConfig): Promise<BlockRazorSubmitResult[]>;
-/**
- * 并行提交多个 Bundle 到 BlockRazor（适用于独立的 Bundle）
- *
- * @param bundles 多个 Bundle 的签名交易数组
- * @param config BlockRazor 提交配置
- * @returns Bundle 提交结果数组
- */
-export declare function submitMultipleBundlesToBlockRazorParallel(bundles: string[][], config: BlockRazorSubmitConfig): Promise<BlockRazorSubmitResult[]>;

package/dist/chains/bsc/four/submit/blockrazor.js

@@ -1,86 +0,0 @@
-import { BlockRazorClient } from '../../../../shared/clients/blockrazor.js';
-const blockRazorClientCache = new Map();
-const CLIENT_CACHE_TTL_MS = 60 * 1000;
-function getBlockRazorClient(config) {
-    const cacheKey = `${config.apiKey || ''}-${config.builderRpcUrl || ''}`;
-    const now = Date.now();
-    const cached = blockRazorClientCache.get(cacheKey);
-    if (cached && cached.expireAt > now)
-        return cached.client;
-    const client = new BlockRazorClient({
-        apiKey: config.apiKey,
-        customRpcUrl: config.customRpcUrl,
-        builderRpcUrl: config.builderRpcUrl,
-        chainId: 56,
-    });
-    blockRazorClientCache.set(cacheKey, { client, expireAt: now + CLIENT_CACHE_TTL_MS });
-    return client;
-}
-export async function submitBundleToBlockRazor(signedTransactions, config) {
-    try {
-        const totalTransactions = signedTransactions?.length ?? 0;
-        // 验证输入
-        if (!signedTransactions || signedTransactions.length === 0) {
-            return {
-                code: false,
-                totalTransactions,
-                error: 'signedTransactions cannot be empty'
-            };
-        }
-        // ✅ 使用缓存的 BlockRazorClient
-        const client = getBlockRazorClient(config);
-        // 提交 Bundle
-        const bundleResult = await client.sendBundle({
-            transactions: signedTransactions,
-            blockOffset: config.blockOffset ?? 100,
-            maxBlockOffset: config.maxBlockOffset ?? 100,
-            noMerge: config.noMerge ?? false,
-            revertingTxHashes: config.revertingTxHashes,
-            autoRetry: config.autoRetry ?? false,
-            maxRetries: config.maxRetries ?? 3
-        });
-        // ✅ 提交成功
-        return {
-            code: true,
-            totalTransactions,
-            bundleHash: bundleResult.bundleHash,
-            txHashes: bundleResult.txHashes,
-            maxBlockNumber: bundleResult.maxBlockNumber,
-            txCount: bundleResult.txCount
-        };
-    }
-    catch (error) {
-        // ❌ 提交失败
-        return {
-            code: false,
-            totalTransactions: signedTransactions?.length ?? 0,
-            error: error?.message || String(error)
-        };
-    }
-}
-/**
- * 批量提交多个 Bundle 到 BlockRazor（顺序执行）
- *
- * @param bundles 多个 Bundle 的签名交易数组
- * @param config BlockRazor 提交配置
- * @returns Bundle 提交结果数组
- */
-export async function submitMultipleBundlesToBlockRazor(bundles, config) {
-    const results = [];
-    for (const signedTransactions of bundles) {
-        const result = await submitBundleToBlockRazor(signedTransactions, config);
-        results.push(result);
-    }
-    return results;
-}
-/**
- * 并行提交多个 Bundle 到 BlockRazor（适用于独立的 Bundle）
- *
- * @param bundles 多个 Bundle 的签名交易数组
- * @param config BlockRazor 提交配置
- * @returns Bundle 提交结果数组
- */
-export async function submitMultipleBundlesToBlockRazorParallel(bundles, config) {
-    const promises = bundles.map(signedTransactions => submitBundleToBlockRazor(signedTransactions, config));
-    return await Promise.all(promises);
-}

package/dist/chains/bsc/four/submit/direct.d.ts

@@ -1,66 +0,0 @@
-import type { DirectSubmitConfig, DirectSubmitResult } from './types.js';
-export declare function submitDirectToRpc(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
-/**
- * ✅ 顺序广播并等待确认（用于多跳交易等需要顺序执行的场景）
- *
- * 每笔交易广播后会等待上链确认，确保后续交易能正确执行
- *
- * ⚠️ 多跳场景：如果某笔交易失败，会立即停止（因为后续交易肯定也会失败）
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export declare function submitDirectToRpcSequential(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
-/**
- * ✅ 顺序广播但不等待确认（用于 AA handleOps + tail 等 nonce 连续的场景）
- *
- * 按顺序逐笔发送交易，每笔只等待广播成功（RPC 返回 txHash），不等待链上确认。
- * 这样可以保证交易按顺序进入 mempool，同时避免等待确认超时。
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export declare function submitDirectToRpcSequentialNoWait(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
-/**
- * 并行逐笔广播到 RPC（速度更快，但可能有 nonce 冲突）
- *
- * ⚠️ 注意：仅适用于不同钱包的交易，同一钱包的多笔交易应使用顺序广播
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export declare function submitDirectToRpcParallel(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
-/**
- * ✅ 智能广播到 RPC（自动选择并行或顺序）
- *
- * 根据交易的发送者地址自动决定广播策略：
- * - 如果所有交易来自不同钱包：使用并行广播（速度快）
- * - 如果存在同一钱包的多笔交易：使用顺序广播（确保 nonce 顺序）
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @param options 额外选项
- * @returns 广播结果（包含使用的模式）
- *
- * @example
- * ```typescript
- * import { submitDirectToRpcSmart } from 'four-flap-meme-sdk';
- *
- * const result = await submitDirectToRpcSmart(signedTransactions, {
- *   rpcUrl: 'https://xlayerrpc.okx.com',
- *   chainId: 196,
- *   chainName: 'XLAYER'
- * });
- *
- * console.log('使用模式:', result.mode);  // 'parallel' 或 'sequential'
- * ```
- */
-export declare function submitDirectToRpcSmart(signedTransactions: string[], config: DirectSubmitConfig, options?: {
-    /** 顺序模式时是否等待确认（默认 false） */
-    waitConfirmation?: boolean;
-}): Promise<DirectSubmitResult & {
-    mode: 'parallel' | 'sequential';
-}>;

package/dist/chains/bsc/four/submit/direct.js

@@ -1,452 +0,0 @@
-import { ethers } from 'ethers';
-import { CHAINS } from '../../../../shared/constants/index.js';
-import { recoverTxHashIfAlreadySeen } from './helpers.js';
-export async function submitDirectToRpc(signedTransactions, config) {
-    const totalTransactions = signedTransactions?.length ?? 0;
-    // 验证输入
-    if (!signedTransactions || signedTransactions.length === 0) {
-        return {
-            code: false,
-            totalTransactions: 0,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: 0,
-            error: 'signedTransactions cannot be empty'
-        };
-    }
-    if (!config.rpcUrl) {
-        return {
-            code: false,
-            totalTransactions,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: totalTransactions,
-            error: 'rpcUrl is required in config'
-        };
-    }
-    const chainId = config.chainId ?? 143;
-    const chainName = config.chainName ?? 'MONAD';
-    // 创建 Provider
-    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
-        chainId,
-        name: chainName
-    });
-    // ✅ 并行广播所有交易
-    const broadcastPromises = signedTransactions.map(async (signedTx, i) => {
-        try {
-            const txResponse = await provider.broadcastTransaction(signedTx);
-            // 如果需要等待确认
-            if (config.waitForConfirmation) {
-                try {
-                    const receipt = await provider.waitForTransaction(txResponse.hash, 1, config.confirmationTimeout ?? 30000);
-                    if (receipt && receipt.status === 0) {
-                        console.warn(`⚠️ [${chainName}] 交易 ${txResponse.hash} 执行失败（已上链但状态为0）`);
-                    }
-                }
-                catch (waitError) {
-                    console.warn(`⚠️ [${chainName}] 等待交易确认超时: ${txResponse.hash}`);
-                }
-            }
-            return {
-                index: i,
-                success: true,
-                txHash: txResponse.hash
-            };
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播失败:`, errorMessage);
-            // ✅ 兼容：nonce too low / already known 等情况下，交易可能已经被接收
-            const recovered = await recoverTxHashIfAlreadySeen(provider, signedTx, errorMessage);
-            if (recovered) {
-                if (config.waitForConfirmation) {
-                    try {
-                        await provider.waitForTransaction(recovered, 1, config.confirmationTimeout ?? 30000);
-                    }
-                    catch { }
-                }
-                return { index: i, success: true, txHash: recovered, error: errorMessage };
-            }
-            return {
-                index: i,
-                success: false,
-                error: errorMessage
-            };
-        }
-    });
-    const results = await Promise.all(broadcastPromises);
-    // 按索引排序结果
-    results.sort((a, b) => a.index - b.index);
-    const txHashes = results.filter(r => r.success && r.txHash).map(r => r.txHash);
-    const errors = results.filter(r => !r.success).map(r => `交易 ${r.index + 1}: ${r.error}`);
-    return {
-        code: txHashes.length > 0,
-        totalTransactions,
-        bundleHash: 'direct',
-        txHashes,
-        txCount: totalTransactions,
-        error: errors.length > 0 ? errors.join('; ') : undefined
-    };
-}
-/**
- * ✅ 顺序广播并等待确认（用于多跳交易等需要顺序执行的场景）
- *
- * 每笔交易广播后会等待上链确认，确保后续交易能正确执行
- *
- * ⚠️ 多跳场景：如果某笔交易失败，会立即停止（因为后续交易肯定也会失败）
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export async function submitDirectToRpcSequential(signedTransactions, config) {
-    const totalTransactions = signedTransactions?.length ?? 0;
-    if (!signedTransactions || signedTransactions.length === 0) {
-        return {
-            code: false,
-            totalTransactions: 0,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: 0,
-            error: 'signedTransactions cannot be empty'
-        };
-    }
-    if (!config.rpcUrl) {
-        return {
-            code: false,
-            totalTransactions,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: totalTransactions,
-            error: 'rpcUrl is required in config'
-        };
-    }
-    const chainId = config.chainId ?? CHAINS.MONAD.chainId;
-    const chainName = config.chainName ?? 'MONAD';
-    // ✅ XLayer 链默认 120 秒超时（网络可能较慢）
-    const confirmationTimeout = config.confirmationTimeout ?? (chainId === CHAINS.XLAYER.chainId ? CHAINS.XLAYER.confirmationTimeout : CHAINS.BSC.confirmationTimeout);
-    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
-        chainId,
-        name: chainName
-    });
-    const results = [];
-    const txHashes = [];
-    const errors = [];
-    console.log(`📤 [${chainName}] 开始顺序广播 ${totalTransactions} 笔交易（等待每笔确认）`);
-    // 顺序广播并等待确认
-    for (let i = 0; i < signedTransactions.length; i++) {
-        const signedTx = signedTransactions[i];
-        try {
-            // 广播交易
-            const txResponse = await provider.broadcastTransaction(signedTx);
-            console.log(`📡 [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播成功: ${txResponse.hash}，等待确认...`);
-            // ✅ 等待交易确认
-            const receipt = await provider.waitForTransaction(txResponse.hash, 1, // 等待1个确认
-            confirmationTimeout);
-            if (receipt && receipt.status === 1) {
-                console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 已确认: ${txResponse.hash}`);
-                results.push({
-                    index: i,
-                    success: true,
-                    txHash: txResponse.hash
-                });
-                txHashes.push(txResponse.hash);
-            }
-            else {
-                const errorMsg = `交易执行失败（status=${receipt?.status})`;
-                console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 上链失败: ${errorMsg}`);
-                results.push({
-                    index: i,
-                    success: false,
-                    txHash: txResponse.hash,
-                    error: errorMsg
-                });
-                errors.push(`交易 ${i + 1}: ${errorMsg}`);
-                // ✅ 多跳场景：如果某笔失败，后续交易肯定也会失败，立即停止
-                console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
-                break;
-            }
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播/确认失败:`, errorMessage);
-            // ✅ 兼容：nonce too low / already known 等情况下，交易可能已经被接收
-            const recovered = await recoverTxHashIfAlreadySeen(provider, signedTx, errorMessage);
-            if (recovered) {
-                console.log(`🔄 [${chainName}] 交易 ${i + 1} 可能已广播，尝试等待确认: ${recovered}`);
-                // 顺序模式依赖确认：尽量等待一下
-                try {
-                    const receipt = await provider.waitForTransaction(recovered, 1, confirmationTimeout);
-                    if (receipt && receipt.status === 1) {
-                        console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 恢复成功: ${recovered}`);
-                        results.push({ index: i, success: true, txHash: recovered, error: errorMessage });
-                        txHashes.push(recovered);
-                        continue;
-                    }
-                    const errorMsg = `交易执行失败（status=${receipt?.status})`;
-                    console.error(`❌ [${chainName}] 交易 ${i + 1} 恢复失败: ${errorMsg}`);
-                    results.push({ index: i, success: false, txHash: recovered, error: `${errorMessage} | ${errorMsg}` });
-                    errors.push(`交易 ${i + 1}: ${errorMessage} | ${errorMsg}`);
-                    // ✅ 多跳场景：失败则停止
-                    console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
-                    break;
-                }
-                catch (waitError) {
-                    // 等待超时：对于多跳场景，不能假设成功，需要停止
-                    const waitErrorMsg = waitError?.message || String(waitError);
-                    console.error(`⏱️ [${chainName}] 交易 ${i + 1} 等待确认超时: ${waitErrorMsg}`);
-                    results.push({ index: i, success: false, txHash: recovered, error: `${errorMessage} | 等待确认超时: ${waitErrorMsg}` });
-                    errors.push(`交易 ${i + 1}: ${errorMessage} | 等待确认超时`);
-                    // ✅ 多跳场景：超时也停止
-                    console.warn(`⚠️ [${chainName}] 多跳模式检测到超时，停止后续 ${totalTransactions - i - 1} 笔交易`);
-                    break;
-                }
-            }
-            results.push({
-                index: i,
-                success: false,
-                error: errorMessage
-            });
-            errors.push(`交易 ${i + 1}: ${errorMessage}`);
-            // ✅ 多跳场景：如果某笔失败，后续交易肯定也会失败，立即停止
-            console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
-            break;
-        }
-    }
-    console.log(`📊 [${chainName}] 顺序广播完成: 成功 ${txHashes.length}/${totalTransactions}`);
-    return {
-        code: txHashes.length > 0,
-        totalTransactions,
-        bundleHash: 'direct',
-        txHashes,
-        txCount: totalTransactions,
-        error: errors.length > 0 ? errors.join('; ') : undefined
-    };
-}
-/**
- * ✅ 顺序广播但不等待确认（用于 AA handleOps + tail 等 nonce 连续的场景）
- *
- * 按顺序逐笔发送交易，每笔只等待广播成功（RPC 返回 txHash），不等待链上确认。
- * 这样可以保证交易按顺序进入 mempool，同时避免等待确认超时。
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export async function submitDirectToRpcSequentialNoWait(signedTransactions, config) {
-    const totalTransactions = signedTransactions?.length ?? 0;
-    if (!signedTransactions || signedTransactions.length === 0) {
-        return {
-            code: false,
-            totalTransactions: 0,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: 0,
-            error: 'signedTransactions cannot be empty'
-        };
-    }
-    if (!config.rpcUrl) {
-        return {
-            code: false,
-            totalTransactions,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: totalTransactions,
-            error: 'rpcUrl is required in config'
-        };
-    }
-    const chainId = config.chainId ?? 143;
-    const chainName = config.chainName ?? 'MONAD';
-    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
-        chainId,
-        name: chainName
-    });
-    const results = [];
-    const txHashes = [];
-    const errors = [];
-    // ✅ 顺序广播，每笔只等待广播成功（不等待链上确认）
-    for (let i = 0; i < signedTransactions.length; i++) {
-        const signedTx = signedTransactions[i];
-        try {
-            // 广播交易，等待 RPC 返回 txHash
-            const txResponse = await provider.broadcastTransaction(signedTx);
-            results.push({
-                index: i,
-                success: true,
-                txHash: txResponse.hash
-            });
-            txHashes.push(txResponse.hash);
-            console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播成功: ${txResponse.hash}`);
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播失败:`, errorMessage);
-            // ✅ 兼容：nonce too low / already known 等情况下，交易可能已经被接收
-            const recovered = await recoverTxHashIfAlreadySeen(provider, signedTx, errorMessage);
-            if (recovered) {
-                results.push({ index: i, success: true, txHash: recovered, error: errorMessage });
-                txHashes.push(recovered);
-                continue;
-            }
-            results.push({
-                index: i,
-                success: false,
-                error: errorMessage
-            });
-            errors.push(`交易 ${i + 1}: ${errorMessage}`);
-            // ✅ 如果某笔失败，继续尝试后续交易（可能是 nonce 问题可以自动恢复）
-        }
-    }
-    return {
-        code: txHashes.length > 0,
-        totalTransactions,
-        bundleHash: 'direct',
-        txHashes,
-        txCount: totalTransactions,
-        error: errors.length > 0 ? errors.join('; ') : undefined
-    };
-}
-/**
- * 并行逐笔广播到 RPC（速度更快，但可能有 nonce 冲突）
- *
- * ⚠️ 注意：仅适用于不同钱包的交易，同一钱包的多笔交易应使用顺序广播
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- */
-export async function submitDirectToRpcParallel(signedTransactions, config) {
-    const totalTransactions = signedTransactions?.length ?? 0;
-    if (!signedTransactions || signedTransactions.length === 0) {
-        return {
-            code: false,
-            totalTransactions: 0,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: 0,
-            error: 'signedTransactions cannot be empty'
-        };
-    }
-    if (!config.rpcUrl) {
-        return {
-            code: false,
-            totalTransactions,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: totalTransactions,
-            error: 'rpcUrl is required in config'
-        };
-    }
-    const chainId = config.chainId ?? 143;
-    const chainName = config.chainName ?? 'MONAD';
-    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
-        chainId,
-        name: chainName
-    });
-    // 并行广播
-    const broadcastPromises = signedTransactions.map(async (signedTx, i) => {
-        try {
-            const txResponse = await provider.broadcastTransaction(signedTx);
-            return {
-                index: i,
-                success: true,
-                txHash: txResponse.hash
-            };
-        }
-        catch (error) {
-            return {
-                index: i,
-                success: false,
-                error: error?.message || String(error)
-            };
-        }
-    });
-    const results = await Promise.all(broadcastPromises);
-    const txHashes = results.filter(r => r.success && r.txHash).map(r => r.txHash);
-    const errors = results.filter(r => !r.success).map(r => `交易 ${r.index + 1}: ${r.error}`);
-    return {
-        code: txHashes.length > 0,
-        totalTransactions,
-        bundleHash: 'direct',
-        txHashes,
-        txCount: totalTransactions,
-        error: errors.length > 0 ? errors.join('; ') : undefined
-    };
-}
-/**
- * ✅ 智能广播到 RPC（自动选择并行或顺序）
- *
- * 根据交易的发送者地址自动决定广播策略：
- * - 如果所有交易来自不同钱包：使用并行广播（速度快）
- * - 如果存在同一钱包的多笔交易：使用顺序广播（确保 nonce 顺序）
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @param options 额外选项
- * @returns 广播结果（包含使用的模式）
- *
- * @example
- * ```typescript
- * import { submitDirectToRpcSmart } from 'four-flap-meme-sdk';
- *
- * const result = await submitDirectToRpcSmart(signedTransactions, {
- *   rpcUrl: 'https://xlayerrpc.okx.com',
- *   chainId: 196,
- *   chainName: 'XLAYER'
- * });
- *
- * console.log('使用模式:', result.mode);  // 'parallel' 或 'sequential'
- * ```
- */
-export async function submitDirectToRpcSmart(signedTransactions, config, options) {
-    const totalTransactions = signedTransactions?.length ?? 0;
-    if (!signedTransactions || signedTransactions.length === 0) {
-        return {
-            code: false,
-            totalTransactions: 0,
-            bundleHash: 'direct',
-            txHashes: [],
-            txCount: 0,
-            error: 'signedTransactions cannot be empty',
-            mode: 'parallel'
-        };
-    }
-    // 检测是否有同一钱包的多笔交易
-    const hasMultipleFromSameWallet = (() => {
-        if (signedTransactions.length < 2)
-            return false;
-        const seen = new Set();
-        for (const raw of signedTransactions) {
-            if (!raw)
-                continue;
-            try {
-                const tx = ethers.Transaction.from(raw);
-                const from = (tx.from || '').toLowerCase();
-                if (!from)
-                    continue;
-                if (seen.has(from))
-                    return true;
-                seen.add(from);
-            }
-            catch {
-                // ignore parse errors
-            }
-        }
-        return false;
-    })();
-    const chainName = config.chainName ?? 'UNKNOWN';
-    if (hasMultipleFromSameWallet) {
-        console.log(`🔄 [${chainName}] 检测到同一钱包多笔交易，使用顺序广播`);
-        // 使用顺序广播
-        const result = options?.waitConfirmation
-            ? await submitDirectToRpcSequential(signedTransactions, config)
-            : await submitDirectToRpcSequentialNoWait(signedTransactions, config);
-        return { ...result, mode: 'sequential' };
-    }
-    else {
-        console.log(`⚡ [${chainName}] 所有交易来自不同钱包，使用并行广播`);
-        // 使用并行广播
-        const result = await submitDirectToRpcParallel(signedTransactions, config);
-        return { ...result, mode: 'parallel' };
-    }
-}

package/dist/chains/bsc/four/submit/helpers.d.ts

@@ -1,18 +0,0 @@
-/**
- * 独立的Bundle提交方法
- *
- * 用于服务器端接收前端构建的签名交易后，提交到Merkle或BlockRazor
- * 以及 Monad 等不支持 Bundle 的链的逐笔广播
- */
-import { MerkleClient } from '../../../../shared/clients/merkle.js';
-import { ethers } from 'ethers';
-import type { MerkleSubmitConfig } from './types.js';
-/**
- * 获取或创建 MerkleClient（带缓存）
- */
-export declare function getMerkleClient(config: MerkleSubmitConfig): MerkleClient;
-/**
- * 精简的Merkle提交配置（只包含提交需要的字段）
- */
-export declare function shouldTreatBroadcastErrorAsMaybeSent(msg: string): boolean;
-export declare function recoverTxHashIfAlreadySeen(provider: ethers.JsonRpcProvider, signedTx: string, errorMessage: string): Promise<string | undefined>;