four-flap-meme-sdk 2.2.1 → 2.2.2

package/dist/bundle-core/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Bundle 共享核心逻辑（Four / TM-Merkle / Flap Portal 共用）
- */
-export { getErc20Decimals, getErc20DecimalsMerkle, generateHopWallets, normalizeAmounts, batchGetBalances, estimateErc20TransferGas, estimateMaxErc20TransferGas, calculateGasLimit, isNativeTokenAddress, type AmountLike, type BundleGasConfig, } from './internal.js';
-export { resolveChainName, createSignProvider, createSignWallet, resolveSignContext, normalizeItemsOrRecipientsAmounts, resolveProvidedHops, resolveHopCountInput, signBribeTransaction, type SignConfigInput, type HopItem, } from './sign-context-helpers.js';
-export { BUNDLE_ERRORS, ERRORS, getBundleErrorMessage, getErrorMessage } from './errors.js';
-export { getTxType, getGasPriceMultiplier, getBundleOptions, getGasPriceConfig, shouldExtractProfit, getProfitRateBps, getProfitRecipient, calculateProfit, calculateBatchProfit, getBribeAmount, type BundleGasConfigInput, type BundleMerkleConfigInput, } from './config-helpers.js';
-export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, submitDirectToRpc, submitDirectToRpcSequential, submitDirectToRpcSequentialNoWait, submitDirectToRpcParallel, submitDirectToRpcSmart, type MerkleSubmitConfig, type SubmitBundleResult, type BlockRazorSubmitConfig, type BlockRazorSubmitResult, type DirectSubmitConfig, type DirectSubmitResult, type DirectTxResult, } from './submit.js';

package/dist/bundle-core/index.js

@@ -1,8 +0,0 @@
-/**
- * Bundle 共享核心逻辑（Four / TM-Merkle / Flap Portal 共用）
- */
-export { getErc20Decimals, getErc20DecimalsMerkle, generateHopWallets, normalizeAmounts, batchGetBalances, estimateErc20TransferGas, estimateMaxErc20TransferGas, calculateGasLimit, isNativeTokenAddress, } from './internal.js';
-export { resolveChainName, createSignProvider, createSignWallet, resolveSignContext, normalizeItemsOrRecipientsAmounts, resolveProvidedHops, resolveHopCountInput, signBribeTransaction, } from './sign-context-helpers.js';
-export { BUNDLE_ERRORS, ERRORS, getBundleErrorMessage, getErrorMessage } from './errors.js';
-export { getTxType, getGasPriceMultiplier, getBundleOptions, getGasPriceConfig, shouldExtractProfit, getProfitRateBps, getProfitRecipient, calculateProfit, calculateBatchProfit, getBribeAmount, } from './config-helpers.js';
-export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, submitDirectToRpc, submitDirectToRpcSequential, submitDirectToRpcSequentialNoWait, submitDirectToRpcParallel, submitDirectToRpcSmart, } from './submit.js';

package/dist/bundle-core/internal.d.ts

@@ -1,21 +0,0 @@
-import { JsonRpcProvider } from 'ethers';
-import type { GeneratedWallet } from '../utils/wallet.js';
-import type { AmountLike, BundleGasConfig } from './types.js';
-/**
- * 获取 ERC20 代币精度（带缓存）
- */
-export declare function getErc20Decimals(provider: JsonRpcProvider, token: string, chainId?: number): Promise<number>;
-/** @deprecated 使用 getErc20Decimals */
-export declare const getErc20DecimalsMerkle: typeof getErc20Decimals;
-/** 生成多跳中间钱包（地址 + 私钥） */
-export declare function generateHopWallets(recipientCount: number, hopCount: number | number[]): GeneratedWallet[][] | null;
-export declare function normalizeAmounts(recipients: string[], amount?: AmountLike, amounts?: AmountLike[]): string[];
-/**
- * 批量获取余额（原生代币或 ERC20，优先 Multicall3）
- */
-export declare function batchGetBalances(provider: JsonRpcProvider, addresses: string[], tokenAddress?: string, chainId?: number): Promise<bigint[]>;
-export declare function estimateErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, to: string, amount: bigint, bufferPercent?: number): Promise<bigint>;
-export declare function estimateMaxErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, recipients: string[], amounts: bigint[], bufferPercent?: number): Promise<bigint>;
-export declare function calculateGasLimit(config: BundleGasConfig, isNative: boolean, hasHops: boolean, hopCount?: number): bigint;
-export declare function isNativeTokenAddress(tokenAddress?: string): boolean;
-export type { AmountLike, BundleGasConfig } from './types.js';

package/dist/bundle-core/internal.js

@@ -1,182 +0,0 @@
-import { ethers, Wallet } from 'ethers';
-import { MULTICALL3_ABI, ERC20_BALANCE_ABI } from '../abis/common.js';
-import { CHAINS, GAS_LIMITS, getMulticall3Address } from '../shared/constants/index.js';
-const decimalsCache = new Map();
-function mapAggregate3Results(results, decode, fallback) {
-    return results.map((result) => {
-        if (result.success && result.returnData && result.returnData !== '0x') {
-            try {
-                return decode(result.returnData);
-            }
-            catch {
-                return fallback;
-            }
-        }
-        return fallback;
-    });
-}
-/**
- * 获取 ERC20 代币精度（带缓存）
- */
-export async function getErc20Decimals(provider, token, chainId) {
-    const resolvedChainId = chainId ?? Number((await provider.getNetwork()).chainId);
-    const key = `${resolvedChainId}_${token.toLowerCase()}`;
-    if (decimalsCache.has(key))
-        return decimalsCache.get(key);
-    try {
-        const erc20 = new ethers.Contract(token, ['function decimals() view returns (uint8)'], provider);
-        const d = await erc20.decimals();
-        if (!Number.isFinite(d) || d < 0 || d > 36)
-            return 18;
-        decimalsCache.set(key, d);
-        return d;
-    }
-    catch {
-        return 18;
-    }
-}
-/** @deprecated 使用 getErc20Decimals */
-export const getErc20DecimalsMerkle = getErc20Decimals;
-/** 生成多跳中间钱包（地址 + 私钥） */
-export function generateHopWallets(recipientCount, hopCount) {
-    const hopCounts = Array.isArray(hopCount) ? hopCount : new Array(recipientCount).fill(hopCount);
-    if (hopCounts.every((h) => h <= 0))
-        return null;
-    const result = [];
-    for (let i = 0; i < recipientCount; i++) {
-        const chain = [];
-        for (let j = 0; j < hopCounts[i]; j++) {
-            const wallet = Wallet.createRandom();
-            chain.push({
-                address: wallet.address,
-                privateKey: wallet.privateKey,
-            });
-        }
-        result.push(chain);
-    }
-    return result;
-}
-export function normalizeAmounts(recipients, amount, amounts) {
-    if (amounts && amounts.length > 0) {
-        if (amounts.length !== recipients.length) {
-            throw new Error(`amounts length (${amounts.length}) must match recipients length (${recipients.length})`);
-        }
-        return amounts.map((a) => (typeof a === 'bigint' ? a.toString() : String(a)));
-    }
-    if (amount !== undefined && String(amount).trim().length > 0) {
-        return new Array(recipients.length).fill(typeof amount === 'bigint' ? amount.toString() : String(amount));
-    }
-    throw new Error('Either amount or amounts must be provided');
-}
-/**
- * 批量获取余额（原生代币或 ERC20，优先 Multicall3）
- */
-export async function batchGetBalances(provider, addresses, tokenAddress, chainId) {
-    if (addresses.length === 0)
-        return [];
-    const resolvedChainId = chainId ?? Number((await provider.getNetwork()).chainId);
-    const multicall3Address = getMulticall3Address(resolvedChainId);
-    const multicall = new ethers.Contract(multicall3Address, MULTICALL3_ABI, provider);
-    if (!tokenAddress) {
-        const multicallIface = new ethers.Interface(MULTICALL3_ABI);
-        const calls = addresses.map((addr) => ({
-            target: multicall3Address,
-            allowFailure: true,
-            callData: multicallIface.encodeFunctionData('getEthBalance', [addr]),
-        }));
-        try {
-            const results = await multicall.aggregate3(calls);
-            return mapAggregate3Results(results, (returnData) => {
-                const decoded = multicallIface.decodeFunctionResult('getEthBalance', returnData);
-                return decoded[0];
-            }, 0n);
-        }
-        catch {
-            return Promise.all(addresses.map((addr) => provider.getBalance(addr).catch(() => 0n)));
-        }
-    }
-    const iface = new ethers.Interface(ERC20_BALANCE_ABI);
-    const calls = addresses.map((addr) => ({
-        target: tokenAddress,
-        allowFailure: true,
-        callData: iface.encodeFunctionData('balanceOf', [addr]),
-    }));
-    try {
-        const results = await multicall.aggregate3(calls);
-        return mapAggregate3Results(results, (returnData) => {
-            return iface.decodeFunctionResult('balanceOf', returnData)[0];
-        }, 0n);
-    }
-    catch {
-        const fallbackCalls = addresses.map((addr) => provider
-            .call({ to: tokenAddress, data: iface.encodeFunctionData('balanceOf', [addr]) })
-            .then((raw) => iface.decodeFunctionResult('balanceOf', raw)[0])
-            .catch(() => 0n));
-        return Promise.all(fallbackCalls);
-    }
-}
-export async function estimateErc20TransferGas(provider, tokenAddress, from, to, amount, bufferPercent = 5) {
-    try {
-        const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-        const data = iface.encodeFunctionData('transfer', [to, amount]);
-        const estimatedGas = await provider.estimateGas({
-            from,
-            to: tokenAddress,
-            data,
-            value: 0n,
-        });
-        const buffer = (estimatedGas * BigInt(bufferPercent)) / 100n;
-        return estimatedGas + buffer;
-    }
-    catch {
-        return 52000n;
-    }
-}
-export async function estimateMaxErc20TransferGas(provider, tokenAddress, from, recipients, amounts, bufferPercent = 5) {
-    if (recipients.length === 0)
-        return 52000n;
-    const sampleIndices = [0];
-    if (recipients.length > 1)
-        sampleIndices.push(Math.min(1, recipients.length - 1));
-    if (recipients.length > 2)
-        sampleIndices.push(Math.min(2, recipients.length - 1));
-    if (recipients.length > 3)
-        sampleIndices.push(recipients.length - 1);
-    const uniqueIndices = [...new Set(sampleIndices)];
-    try {
-        const estimates = await Promise.all(uniqueIndices.map((i) => estimateErc20TransferGas(provider, tokenAddress, from, recipients[i], amounts[i], bufferPercent)));
-        return estimates.reduce((max, gas) => (gas > max ? gas : max), 0n);
-    }
-    catch {
-        return 52000n;
-    }
-}
-export function calculateGasLimit(config, isNative, hasHops, hopCount = 0) {
-    if (config.gasLimit !== undefined) {
-        return BigInt(config.gasLimit);
-    }
-    const isXLayer = config.chainId === CHAINS.XLAYER.chainId;
-    const baseGas = isNative
-        ? isXLayer
-            ? Number(GAS_LIMITS.XLAYER_NATIVE_TRANSFER)
-            : Number(GAS_LIMITS.NATIVE_TRANSFER)
-        : 46815;
-    if (hasHops && hopCount > 0) {
-        const multiplier = config.gasLimitMultiplier ?? 1.1;
-        return BigInt(Math.ceil(baseGas * multiplier));
-    }
-    const multiplier = config.gasLimitMultiplier ?? 1.1;
-    return BigInt(Math.ceil(baseGas * multiplier));
-}
-export function isNativeTokenAddress(tokenAddress) {
-    if (!tokenAddress)
-        return true;
-    const v = tokenAddress.trim().toLowerCase();
-    if (!v)
-        return true;
-    if (v === 'native')
-        return true;
-    if (v === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
-        return true;
-    return false;
-}

package/dist/bundle-core/sign-context-helpers.d.ts

@@ -1,25 +0,0 @@
-import { ethers, Wallet } from 'ethers';
-import { type BundleGasConfigInput } from './config-helpers.js';
-export type SignConfigInput = BundleGasConfigInput & {
-    rpcUrl: string;
-    chainId?: number;
-};
-export type HopItem = {
-    hopPrivateKeys?: string[];
-    hopCount?: number;
-};
-export declare function resolveChainName(chainIdNum: number): string;
-export declare function createSignProvider(rpcUrl: string, chainIdNum: number, chainName?: string): ethers.JsonRpcProvider;
-export declare function createSignWallet(fromPrivateKey: string, provider: ethers.JsonRpcProvider): Wallet;
-export declare function resolveSignContext(config: SignConfigInput, fromPrivateKey: string): {
-    chainIdNum: number;
-    provider: ethers.JsonRpcProvider;
-    mainWallet: ethers.Wallet;
-    txType: 0 | 2;
-};
-export declare function normalizeItemsOrRecipientsAmounts(recipients: string[], items: Array<{
-    amount: string | number | bigint;
-}> | undefined, amount: string | number | bigint | undefined, amounts: Array<string | number | bigint> | undefined, normalize: (recipients: string[], amount?: string | number | bigint, amounts?: Array<string | number | bigint>) => string[]): string[];
-export declare function resolveProvidedHops(recipientCount: number, hopPrivateKeys?: string[][], items?: HopItem[]): string[][] | null;
-export declare function resolveHopCountInput(recipientCount: number, hopCount: number | number[], items?: HopItem[]): number | number[];
-export declare function signBribeTransaction(wallet: Wallet, bribeAmount: bigint, nonce: number, gasPrice: bigint, chainIdNum: number, txType: 0 | 2): Promise<string>;

package/dist/bundle-core/sign-context-helpers.js

@@ -1,67 +0,0 @@
-import { ethers, Wallet } from 'ethers';
-import { BLOCKRAZOR_BUILDER_EOA } from '../shared/constants/index.js';
-import { getTxType } from './config-helpers.js';
-export function resolveChainName(chainIdNum) {
-    if (chainIdNum === 143)
-        return 'Monad';
-    if (chainIdNum === 56)
-        return 'BSC';
-    return `Chain-${chainIdNum}`;
-}
-export function createSignProvider(rpcUrl, chainIdNum, chainName) {
-    return new ethers.JsonRpcProvider(rpcUrl, {
-        chainId: chainIdNum,
-        name: chainName ?? resolveChainName(chainIdNum),
-        ensAddress: undefined,
-    });
-}
-export function createSignWallet(fromPrivateKey, provider) {
-    return new Wallet(fromPrivateKey, provider);
-}
-export function resolveSignContext(config, fromPrivateKey) {
-    const chainIdNum = config.chainId ?? 56;
-    const provider = createSignProvider(config.rpcUrl, chainIdNum);
-    return {
-        chainIdNum,
-        provider,
-        mainWallet: createSignWallet(fromPrivateKey, provider),
-        txType: getTxType(config),
-    };
-}
-export function normalizeItemsOrRecipientsAmounts(recipients, items, amount, amounts, normalize) {
-    if (items && items.length > 0) {
-        return items.map((it) => (typeof it.amount === 'bigint' ? it.amount.toString() : String(it.amount)));
-    }
-    return normalize(recipients, amount, amounts);
-}
-export function resolveProvidedHops(recipientCount, hopPrivateKeys, items) {
-    if (hopPrivateKeys && hopPrivateKeys.length > 0) {
-        if (hopPrivateKeys.length !== recipientCount) {
-            throw new Error(`hopPrivateKeys length (${hopPrivateKeys.length}) must match recipients length (${recipientCount})`);
-        }
-        return hopPrivateKeys.every((h) => h.length === 0) ? null : hopPrivateKeys;
-    }
-    if (items && items.length > 0) {
-        const hops = items.map((it) => it.hopPrivateKeys ?? []);
-        return hops.every((h) => h.length === 0) ? null : hops;
-    }
-    return null;
-}
-export function resolveHopCountInput(recipientCount, hopCount, items) {
-    if (items && items.length > 0) {
-        const baseArray = Array.isArray(hopCount) ? hopCount : new Array(recipientCount).fill(hopCount);
-        return items.map((it, i) => (typeof it.hopCount === 'number' ? it.hopCount : (baseArray[i] ?? 0)));
-    }
-    return hopCount;
-}
-export async function signBribeTransaction(wallet, bribeAmount, nonce, gasPrice, chainIdNum, txType) {
-    return wallet.signTransaction({
-        to: BLOCKRAZOR_BUILDER_EOA,
-        value: bribeAmount,
-        nonce,
-        gasPrice,
-        gasLimit: 21000n,
-        chainId: BigInt(chainIdNum),
-        type: txType,
-    });
-}

package/dist/bundle-core/submit.d.ts

@@ -1,293 +0,0 @@
-/**
- * 独立的Bundle提交方法
- *
- * 用于服务器端接收前端构建的签名交易后，提交到Merkle或BlockRazor
- * 以及 Monad 等不支持 Bundle 的链的逐笔广播
- */
-/**
- * 精简的Merkle提交配置（只包含提交需要的字段）
- */
-export interface MerkleSubmitConfig {
-    /** Merkle API Key（必需） */
-    apiKey: string;
-    /** 自定义RPC URL（可选） */
-    customRpcUrl?: string;
-    /** 链ID（可选，默认56=BSC） */
-    chainId?: 56 | 1;
-    /** Bundle区块偏移量（可选，默认3） */
-    bundleBlockOffset?: number;
-    /** 最小区块偏移量（可选，默认3） */
-    minBlockOffset?: number;
-    /** 是否自动重试（可选，默认false） */
-    autoRetryBundle?: boolean;
-    /** 最大重试次数（可选，默认2） */
-    maxBundleRetries?: number;
-}
-/**
- * Bundle提交结果
- */
-export interface SubmitBundleResult {
-    /** 提交状态：true=成功，false=失败 */
-    code: boolean;
-    /** 交易总数（无论成功与否都会返回） */
-    totalTransactions: number;
-    /** Bundle哈希（成功时返回） */
-    bundleHash?: string;
-    /** 交易哈希列表（成功时返回） */
-    txHashes?: string[];
-    /** 目标区块号（成功时返回） */
-    targetBlock?: number;
-    /** 交易数量（成功时返回） */
-    txCount?: number;
-    /** 错误信息（失败时返回） */
-    error?: string;
-}
-/**
- * 提交已签名的交易到Merkle（服务器端使用）
- *
- * 这个方法接收前端构建和签名好的交易，直接提交到Merkle服务
- *
- * @param signedTransactions 签名后的交易数组
- * @param config Merkle提交配置（精简版，只需要提交相关参数）
- * @returns Bundle提交结果
- *
- * @example
- * ```typescript
- * // 服务器端代码
- * import { submitBundleToMerkle } from 'four-flap-meme-sdk';
- *
- * const result = await submitBundleToMerkle(signedTransactions, {
- *   apiKey: process.env.MERKLE_API_KEY,
- *   customRpcUrl: process.env.MERKLE_RPC_URL,
- *   bundleBlockOffset: 5
- * });
- *
- * if (result.code) {
- * } else {
- *   console.error('❌ Bundle提交失败:', result.error);
- * }
- * ```
- */
-export declare function submitBundleToMerkle(signedTransactions: string[], config: MerkleSubmitConfig): Promise<SubmitBundleResult>;
-/**
- * 批量提交多个Bundle到Merkle（顺序执行）
- *
- * @param bundles 多个Bundle的签名交易数组
- * @param config Merkle提交配置
- * @returns Bundle提交结果数组
- */
-export declare function submitMultipleBundles(bundles: string[][], config: MerkleSubmitConfig): Promise<SubmitBundleResult[]>;
-/**
- * 并行提交多个Bundle到Merkle（适用于独立的Bundle）
- *
- * @param bundles 多个Bundle的签名交易数组
- * @param config Merkle提交配置
- * @returns Bundle提交结果数组
- */
-export declare function submitMultipleBundlesParallel(bundles: string[][], config: MerkleSubmitConfig): Promise<SubmitBundleResult[]>;
-/**
- * BlockRazor 提交配置
- * 参考: https://blockrazor.gitbook.io/blockrazor/bsc/block-builder/send-bundle
- */
-export interface BlockRazorSubmitConfig {
-    /** API Key（可选，根据 Tier 需要） */
-    apiKey?: string;
-    /** 自定义 RPC URL（用于查询区块号等，可选） */
-    customRpcUrl?: string;
-    /** Builder RPC URL（用于发送 Bundle，可选） */
-    builderRpcUrl?: string;
-    /** 区块偏移量（默认 10，最大有效区块 = 当前区块 + offset） */
-    blockOffset?: number;
-    /** 最大区块偏移量（默认 100） */
-    maxBlockOffset?: number;
-    /** 是否禁止 Bundle 合并（默认 false，允许合并可提高打包率） */
-    noMerge?: boolean;
-    /** 允许 revert 的交易哈希列表 */
-    revertingTxHashes?: string[];
-    /** 是否自动重试（默认 false） */
-    autoRetry?: boolean;
-    /** 最大重试次数（默认 3） */
-    maxRetries?: number;
-}
-/**
- * BlockRazor Bundle 提交结果
- */
-export interface BlockRazorSubmitResult {
-    /** 提交状态：true=成功，false=失败 */
-    code: boolean;
-    /** 交易总数 */
-    totalTransactions: number;
-    /** Bundle 哈希（成功时返回） */
-    bundleHash?: string;
-    /** 交易哈希列表（成功时返回） */
-    txHashes?: string[];
-    /** 最大有效区块号（成功时返回） */
-    maxBlockNumber?: number;
-    /** 交易数量（成功时返回） */
-    txCount?: number;
-    /** 错误信息（失败时返回） */
-    error?: string;
-}
-/**
- * 提交已签名的交易到 BlockRazor（服务器端使用）
- *
- * BlockRazor 是 BSC 链的 Block Builder 服务，支持 Bundle 提交
- *
- * 特点：
- * - 向 Builder EOA 转账 BNB 可提高优先级
- * - 支持 Bundle 合并提高打包率
- * - 最低 Gas Price 要求: 0.05 Gwei
- *
- * @param signedTransactions 签名后的交易数组
- * @param config BlockRazor 提交配置
- * @returns Bundle 提交结果
- *
- * @example
- * ```typescript
- * // 服务器端代码
- * import { submitBundleToBlockRazor } from 'four-flap-meme-sdk';
- *
- * const result = await submitBundleToBlockRazor(signedTransactions, {
- *   blockOffset: 10,
- *   noMerge: false,  // 允许合并
- *   autoRetry: true
- * });
- *
- * if (result.code) {
- * } else {
- *   console.error('❌ Bundle 提交失败:', result.error);
- * }
- * ```
- */
-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[]>;
-/**
- * 逐笔广播配置（用于不支持 Bundle 的链，如 Monad）
- */
-export interface DirectSubmitConfig {
-    /** RPC URL（必需） */
-    rpcUrl: string;
-    /** 链ID（可选，默认143=Monad） */
-    chainId?: number;
-    /** 链名称（可选，用于日志） */
-    chainName?: string;
-    /** 是否等待交易确认（可选，默认false） */
-    waitForConfirmation?: boolean;
-    /** 确认超时时间ms（可选，默认30000） */
-    confirmationTimeout?: number;
-}
-/**
- * 单笔交易结果
- */
-export interface DirectTxResult {
-    /** 交易索引 */
-    index: number;
-    /** 是否成功 */
-    success: boolean;
-    /** 交易哈希（成功时返回） */
-    txHash?: string;
-    /** 错误信息（失败时返回） */
-    error?: string;
-}
-/**
- * 逐笔广播提交结果
- */
-export interface DirectSubmitResult {
-    /** 提交状态：至少有一笔成功则为true */
-    code: boolean;
-    /** 交易总数 */
-    totalTransactions: number;
-    /** 成功数量 */
-    successCount: number;
-    /** 失败数量 */
-    failedCount: number;
-    /** 交易哈希列表（成功的交易） */
-    txHashes: string[];
-    /** 每笔交易的详细结果 */
-    results: DirectTxResult[];
-    /** 错误摘要（如果有失败） */
-    errorSummary?: string;
-}
-/**
- * 并行广播到 RPC（用于不支持 Bundle 的链，如 Monad）
- *
- * ✅ 优化：默认使用并行广播，速度更快
- *
- * @param signedTransactions 签名后的交易数组
- * @param config 直接广播配置
- * @returns 广播结果
- *
- * @example
- * ```typescript
- * // 服务器端代码（Monad 链）
- * import { submitDirectToRpc } from 'four-flap-meme-sdk';
- *
- * const result = await submitDirectToRpc(signedTransactions, {
- *   rpcUrl: 'https://rpc-mainnet.monadinfra.com',
- *   chainId: 143,
- *   chainName: 'MONAD'
- * });
- *
- * if (result.code) {
- * } else {
- *   console.error('❌ 全部广播失败:', result.errorSummary);
- * }
- * ```
- */
-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（自动选择并行或顺序）
- */
-export declare function submitDirectToRpcSmart(signedTransactions: string[], config: DirectSubmitConfig, options?: {
-    waitConfirmation?: boolean;
-}): Promise<DirectSubmitResult & {
-    mode: 'parallel' | 'sequential';
-}>;