four-flap-meme-sdk 2.2.19 → 3.0.0

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.js

@@ -1,113 +0,0 @@
-import { ethers, Wallet } from 'ethers';
-import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
-import { ADDRESSES } from '../../utils/constants.js';
-import { ERC20_ABI } from '../../shared/abis/common.js';
-import { getTxType, getGasPriceConfig } from './config.js';
-import { batchCheckAllowances } from '../../utils/erc20.js';
-/**
- * 批量授权代币给 TokenManager（用于 Private Buy/Sell）
- * ✅ 直接通过 RPC 提交到链上并等待确认
- * ✅ 不需要 Merkle API Key，使用普通 RPC 即可
- * ✅ 专门用于授权给 TokenManagerOriginal 合约
- * ✅ 用于 fourBatchPrivateSell 和 fourBatchSellWithBundleMerkle
- * ✅ 优化：并行获取 gasPrice、decimals、allowances
- */
-export async function approveFourTokenManagerBatch(params) {
-    const { privateKeys, tokenAddress, amounts, config } = params;
-    if (privateKeys.length === 0 || amounts.length !== privateKeys.length) {
-        throw new Error('Private key count and amount count must match');
-    }
-    const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
-    const chainId = config.chainId ?? 56;
-    // ✅ 直接使用传入的 RPC URL 创建 provider（不依赖 Merkle）
-    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
-        chainId: chainId,
-        name: 'BSC'
-    });
-    const wallets = privateKeys.map(k => new Wallet(k, provider));
-    const allMax = amounts.every(a => a === 'max');
-    // ✅ 优化：并行获取 gasPrice、decimals（如果需要）、allowances
-    const [gasPrice, decimals, allowances] = await Promise.all([
-        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
-        allMax
-            ? Promise.resolve(18) // 如果都是 'max'，不需要查询 decimals
-            : (async () => {
-                try {
-                    const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-                    return await tokenContract.decimals();
-                }
-                catch (error) {
-                    throw new Error(`查询代币 decimals 失败: ${error.message}`);
-                }
-            })(),
-        batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr)
-    ]);
-    const amountsBigInt = amounts.map(a => a === 'max' ? ethers.MaxUint256 : ethers.parseUnits(a, decimals));
-    // 只授权不足的
-    // ✅ 策略：如果授权额度 < MaxUint256 / 2n，就重新授权（确保授权足够大）
-    const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
-    const needApproval = wallets.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
-    const needApprovalAmounts = amountsBigInt.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
-    const skippedCount = wallets.length - needApproval.length;
-    if (needApproval.length === 0) {
-        return {
-            success: true,
-            signedTransactions: [],
-            approvedCount: 0,
-            skippedCount: skippedCount,
-            message: '所有钱包已授权，无需重复授权'
-        };
-    }
-    // ✅ 优化：计算 gasLimit（不需要 RPC）
-    const getGasLimit = (cfg) => {
-        if (cfg.gasLimit)
-            return BigInt(cfg.gasLimit);
-        if (cfg.gasLimitMultiplier)
-            return BigInt(Math.ceil(60000 * cfg.gasLimitMultiplier));
-        return 60000n; // 默认授权 gas limit
-    };
-    const finalGasLimit = getGasLimit(config);
-    const txType = getTxType(config);
-    // ✅ 优化：并行获取 nonces 和构建未签名交易
-    const nonceManager = new NonceManager(provider);
-    const needApprovalTokens = needApproval.map(w => new ethers.Contract(tokenAddress, ERC20_ABI, w));
-    const [nonces, unsignedApprovals] = await Promise.all([
-        nonceManager.getNextNoncesForWallets(needApproval), // ✅ 批量获取 nonces（JSON-RPC 批量请求）
-        Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i])))
-    ]);
-    // ✅ 并行签名所有授权交易
-    const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
-        ...unsigned,
-        from: needApproval[i].address,
-        nonce: nonces[i],
-        gasLimit: finalGasLimit,
-        gasPrice,
-        chainId,
-        type: txType
-    })));
-    nonceManager.clearTemp();
-    try {
-        // ✅ 并行广播所有授权交易
-        const txResponses = await Promise.all(signedTxs.map(tx => provider.broadcastTransaction(tx)));
-        const txHashes = txResponses.map(r => r.hash);
-        // ✅ 并行等待所有授权交易确认（至少1个确认）
-        await Promise.all(txResponses.map(tx => tx.wait(1)));
-        return {
-            success: true,
-            signedTransactions: signedTxs,
-            approvedCount: signedTxs.length,
-            skippedCount: skippedCount,
-            txHashes: txHashes,
-            message: `授权成功！共 ${signedTxs.length} 个钱包已授权，跳过 ${skippedCount} 个已授权钱包`
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            signedTransactions: signedTxs,
-            approvedCount: 0,
-            skippedCount: skippedCount,
-            message: `授权提交失败: ${error.message}`
-        };
-    }
-}

package/dist/contracts/tm-bundle-merkle/config.d.ts

@@ -1,70 +0,0 @@
-import type { FourBundleMerkleConfig, FourSignConfig } from './types.js';
-export type { FourBundleMerkleConfig, FourSignConfig };
-export type FourAnyConfig = FourBundleMerkleConfig | FourSignConfig;
-export declare const ERRORS: {
-    NO_PRIVATE_KEY: {
-        en: string;
-        zh: string;
-    };
-    AMOUNT_MISMATCH: {
-        en: (buyCount: number, buyerCount: number) => string;
-        zh: (buyCount: number, buyerCount: number) => string;
-    };
-    IMAGE_REQUIRED: {
-        en: string;
-        zh: string;
-    };
-    KEY_AMOUNT_MISMATCH: {
-        en: string;
-        zh: string;
-    };
-    SELL_KEY_AMOUNT_MISMATCH: {
-        en: string;
-        zh: string;
-    };
-};
-export declare function getErrorMessage(key: keyof typeof ERRORS, ...args: any[]): string;
-export declare function getTxType(config: FourAnyConfig): 0 | 2;
-export declare function getGasPriceMultiplier(config: FourAnyConfig): number;
-export declare function getBundleOptions(config: FourBundleMerkleConfig, blockOffset?: number): {
-    blockOffset: number;
-    minBlockOffset: number;
-    autoRetry: boolean;
-    maxRetries: number;
-};
-export declare function getGasPriceConfig(config: FourAnyConfig): any;
-/**
- * 判断是否需要提取利润
- * ✅ 强制开启，始终返回 true
- */
-export declare function shouldExtractProfit(config?: FourAnyConfig): boolean;
-/**
- * 获取利润比例（基点）
- * ✅ 硬编码：30 bps = 0.3% = 千分之3
- */
-export declare function getProfitRateBps(config?: FourAnyConfig): number;
-/**
- * 获取利润接收地址
- */
-export declare function getProfitRecipient(config?: FourAnyConfig): string;
-/**
- * 计算利润金额
- * ✅ 强制提取利润：使用硬编码的利润率
- */
-export declare function calculateProfit(amount: bigint, config?: FourAnyConfig): {
-    profit: bigint;
-    remaining: bigint;
-};
-/**
- * 批量计算利润
- * ✅ 强制提取利润：使用硬编码的利润率
- */
-export declare function calculateBatchProfit(amounts: bigint[], config?: FourAnyConfig): {
-    totalProfit: bigint;
-    remainingAmounts: bigint[];
-};
-/**
- * 获取贿赂金额（Wei）
- * ✅ 从配置中读取贿赂金额，转换为 Wei
- */
-export declare function getBribeAmount(config?: FourAnyConfig): bigint;

package/dist/contracts/tm-bundle-merkle/config.js

@@ -1,114 +0,0 @@
-import { ethers } from 'ethers';
-import { PROFIT_CONFIG } from '../../utils/constants.js';
-// 错误信息国际化
-export const ERRORS = {
-    NO_PRIVATE_KEY: {
-        en: 'At least 1 private key (creator) is required',
-        zh: '至少需要 1 个私钥（创建者）'
-    },
-    AMOUNT_MISMATCH: {
-        en: (buyCount, buyerCount) => `Buy amount count (${buyCount}) must equal buyer count (${buyerCount})`,
-        zh: (buyCount, buyerCount) => `购买金额数量(${buyCount})必须等于买家数量(${buyerCount})`
-    },
-    IMAGE_REQUIRED: {
-        en: 'Either imageUrl or imageFile must be provided',
-        zh: '必须提供 imageUrl 或 imageFile'
-    },
-    KEY_AMOUNT_MISMATCH: {
-        en: 'Private key count and amount count must match',
-        zh: '私钥和购买金额数量必须一致'
-    },
-    SELL_KEY_AMOUNT_MISMATCH: {
-        en: 'Private key count and sell amount count must match',
-        zh: '私钥和卖出数量必须一致'
-    }
-};
-export function getErrorMessage(key, ...args) {
-    const lang = (process.env.LANG || process.env.LANGUAGE || 'en').toLowerCase().includes('zh') ? 'zh' : 'en';
-    const message = ERRORS[key][lang];
-    return typeof message === 'function' ? message(...args) : message;
-}
-export function getTxType(config) {
-    return config.txType ?? 0;
-}
-export function getGasPriceMultiplier(config) {
-    return config.gasPriceMultiplierPercent ?? 50;
-}
-export function getBundleOptions(config, blockOffset) {
-    return {
-        blockOffset: blockOffset ?? config.bundleBlockOffset ?? 3,
-        minBlockOffset: config.minBlockOffset ?? 3,
-        autoRetry: config.autoRetryBundle ?? false,
-        maxRetries: config.maxBundleRetries ?? 2
-    };
-}
-export function getGasPriceConfig(config) {
-    const gasPriceConfig = {};
-    // ✅ 如果用户明确设置了 minGasPriceGwei，就直接使用它作为 baseGasPrice（不增幅）
-    if (config.minGasPriceGwei !== undefined) {
-        gasPriceConfig.baseGasPrice = ethers.parseUnits(String(config.minGasPriceGwei), 'gwei');
-        gasPriceConfig.multiplierPercent = 0; // 不增幅
-    }
-    else {
-        // 否则使用默认增幅策略
-        gasPriceConfig.multiplierPercent = getGasPriceMultiplier(config);
-    }
-    return gasPriceConfig;
-}
-// ========================================
-// 利润提取相关辅助函数
-// ========================================
-/**
- * 判断是否需要提取利润
- * ✅ 强制开启，始终返回 true
- */
-export function shouldExtractProfit(config) {
-    return true; // 强制提取利润
-}
-/**
- * 获取利润比例（基点）
- * ✅ 硬编码：30 bps = 0.3% = 千分之3
- */
-export function getProfitRateBps(config) {
-    return PROFIT_CONFIG.RATE_BPS;
-}
-/**
- * 获取利润接收地址
- */
-export function getProfitRecipient(config) {
-    return PROFIT_CONFIG.RECIPIENT;
-}
-/**
- * 计算利润金额
- * ✅ 强制提取利润：使用硬编码的利润率
- */
-export function calculateProfit(amount, config) {
-    // ✅ 强制提取利润
-    const profit = (amount * BigInt(PROFIT_CONFIG.RATE_BPS)) / 10000n;
-    const remaining = amount - profit;
-    return { profit, remaining };
-}
-/**
- * 批量计算利润
- * ✅ 强制提取利润：使用硬编码的利润率
- */
-export function calculateBatchProfit(amounts, config) {
-    let totalProfit = 0n;
-    const remainingAmounts = [];
-    for (const amount of amounts) {
-        const { profit, remaining } = calculateProfit(amount, config);
-        totalProfit += profit;
-        remainingAmounts.push(remaining);
-    }
-    return { totalProfit, remainingAmounts };
-}
-/**
- * 获取贿赂金额（Wei）
- * ✅ 从配置中读取贿赂金额，转换为 Wei
- */
-export function getBribeAmount(config) {
-    if (!config || !config.bribeAmount || config.bribeAmount <= 0) {
-        return 0n;
-    }
-    return ethers.parseEther(String(config.bribeAmount));
-}

package/dist/contracts/tm-bundle-merkle/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * four.meme Bundle 交易方法（Merkle 版本）
- * 使用 Merkle.io Bundle 服务实现原子化交易
- */
-export * from './config.js';
-export * from './types.js';
-export { createTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle, batchSellWithBundleMerkle } from './core.js';
-export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle } from './private.js';
-export { disperseWithBundleMerkle, sweepWithBundleMerkle, pairwiseTransferWithBundleMerkle } from './utils.js';
-export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approveFourPancakeProxy, approveFourPancakeProxyBatch } from './pancake-proxy.js';
-export { approveFourTokenManagerBatch, type ApproveFourTokenManagerBatchParams, type ApproveFourTokenManagerBatchResult } from './approve-tokenmanager.js';
-export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, type MerkleSubmitConfig, type SubmitBundleResult, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, type BlockRazorSubmitConfig, type BlockRazorSubmitResult, submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
-submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
-submitDirectToRpcParallel, type DirectSubmitConfig, type DirectSubmitResult, type DirectTxResult } from './submit.js';
-export { fourBundleBuyFirstMerkle, type FourBundleBuyFirstSignParams, type FourBuyFirstSignConfig, type FourBuyFirstResult } from './swap-buy-first.js';

package/dist/contracts/tm-bundle-merkle/index.js

@@ -1,29 +0,0 @@
-/**
- * four.meme Bundle 交易方法（Merkle 版本）
- * 使用 Merkle.io Bundle 服务实现原子化交易
- */
-// 配置和类型
-export * from './config.js';
-export * from './types.js';
-// 核心交易方法
-export { createTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle, batchSellWithBundleMerkle } from './core.js';
-// 私有交易方法
-export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle } from './private.js';
-// 工具方法
-export { disperseWithBundleMerkle, sweepWithBundleMerkle, pairwiseTransferWithBundleMerkle } from './utils.js';
-// PancakeSwapProxy 代理交易方法
-export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approveFourPancakeProxy, approveFourPancakeProxyBatch } from './pancake-proxy.js';
-// TokenManager 授权方法
-export { approveFourTokenManagerBatch } from './approve-tokenmanager.js';
-// Bundle提交方法（服务器端使用）
-export { 
-// Merkle 提交方法
-submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, 
-// ✅ BlockRazor 提交方法
-submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, 
-// ✅ Monad 等链的逐笔广播方法
-submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
-submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
-submitDirectToRpcParallel } from './submit.js';
-// 先买后卖换手方法
-export { fourBundleBuyFirstMerkle } from './swap-buy-first.js';

package/dist/contracts/tm-bundle-merkle/internal.d.ts

@@ -1,48 +0,0 @@
-import { JsonRpcProvider } from 'ethers';
-import type { AmountLike } from './types.js';
-import type { GeneratedWallet } from '../../utils/wallet.js';
-/**
- * 获取 ERC20 代币精度（带缓存）
- * ✅ 优化：避免每次调用都获取 network，直接使用传入的 chainId
- */
-export declare function getErc20DecimalsMerkle(provider: JsonRpcProvider, token: string, chainId?: number): Promise<number>;
-/**
- * ✅ 生成多跳中间钱包（返回完整钱包信息：地址 + 私钥）
- */
-export declare function generateHopWallets(recipientCount: number, hopCount: number | number[]): GeneratedWallet[][] | null;
-export declare function normalizeAmounts(recipients: string[], amount?: AmountLike, amounts?: AmountLike[]): string[];
-/**
- * 批量获取余额（原生代币或 ERC20）
- * ✅ 优化：原生代币也使用 Multicall3 批量获取，减少 RPC 调用
- */
-export declare function batchGetBalances(provider: JsonRpcProvider, addresses: string[], tokenAddress?: string): Promise<bigint[]>;
-/**
- * 通过模拟交易获取 ERC20 转账的最小 Gas Limit
- * ✅ 使用 eth_estimateGas 预估实际需要的 gas，然后加一个小的缓冲量
- *
- * @param provider - Provider 实例
- * @param tokenAddress - ERC20 代币地址
- * @param from - 发送方地址
- * @param to - 接收方地址
- * @param amount - 转账金额（wei）
- * @param bufferPercent - 缓冲百分比（默认 5%）
- * @returns 预估的 gas limit
- */
-export declare function estimateErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, to: string, amount: bigint, bufferPercent?: number): Promise<bigint>;
-/**
- * 批量预估多个 ERC20 转账的 Gas Limit
- * ✅ 选取最大值作为统一的 gas limit（确保所有转账都能成功）
- */
-export declare function estimateMaxErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, recipients: string[], amounts: bigint[], bufferPercent?: number): Promise<bigint>;
-/**
- * 计算 Gas Limit
- * - 原生代币转账：
- *   - BSC: 21000 gas（固定）
- *   - XLayer: 50000 gas（EIP-7702 授权地址需要更多 gas）
- * - ERC20 标准 transfer：约 45000-55000 gas，使用 55000 作为安全值
- *
- * ✅ 优化：降低 ERC20 gas limit，减少中转钱包 BNB 残留
- * ✅ XLayer 特殊处理：EIP-7702 授权的地址接收 OKB 时会触发 delegate 代码，需要更多 gas
- */
-export declare function calculateGasLimit(config: any, isNative: boolean, hasHops: boolean, hopCount?: number): bigint;
-export declare function isNativeTokenAddress(tokenAddress?: string): boolean;

package/dist/contracts/tm-bundle-merkle/internal.js

@@ -1,240 +0,0 @@
-import { ethers, Wallet } from 'ethers';
-import { ADDRESSES } from '../../utils/constants.js';
-import { MULTICALL3_ABI, ERC20_BALANCE_ABI } from '../../shared/abis/common.js';
-// 内部缓存：ERC20 小数位
-const decimalsCache = new Map();
-/**
- * 获取 ERC20 代币精度（带缓存）
- * ✅ 优化：避免每次调用都获取 network，直接使用传入的 chainId
- */
-export async function getErc20DecimalsMerkle(provider, token, chainId) {
-    // ✅ 修复：不访问 provider._network（ethers v6 可能未准备好导致 NETWORK_ERROR）
-    // 直接使用传入的 chainId，如果没传则默认 56 (BSC)
-    const resolvedChainId = chainId ?? 56;
-    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;
-    }
-}
-/**
- * ✅ 生成多跳中间钱包（返回完整钱包信息：地址 + 私钥）
- */
-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 批量获取，减少 RPC 调用
- */
-export async function batchGetBalances(provider, addresses, tokenAddress) {
-    if (addresses.length === 0)
-        return [];
-    // ✅ 使用公共模块
-    const MULTICALL3_ADDRESS = ADDRESSES.BSC.Multicall3;
-    const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
-    if (!tokenAddress) {
-        // ✅ 优化：原生代币使用 Multicall3.getEthBalance 批量获取（单次 RPC 调用）
-        const multicallIface = new ethers.Interface(MULTICALL3_ABI);
-        const calls = addresses.map(addr => ({
-            target: MULTICALL3_ADDRESS,
-            allowFailure: true,
-            callData: multicallIface.encodeFunctionData('getEthBalance', [addr])
-        }));
-        try {
-            const results = await multicall.aggregate3(calls);
-            return results.map((result) => {
-                if (result.success && result.returnData && result.returnData !== '0x') {
-                    try {
-                        const decoded = multicallIface.decodeFunctionResult('getEthBalance', result.returnData);
-                        return decoded[0];
-                    }
-                    catch {
-                        return 0n;
-                    }
-                }
-                return 0n;
-            });
-        }
-        catch {
-            // ✅ 回退：并行调用（如果 Multicall3 失败）
-            return Promise.all(addresses.map(addr => provider.getBalance(addr).catch(() => 0n)));
-        }
-    }
-    else {
-        // ✅ ERC20 余额：使用 Multicall3 批量获取
-        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 results.map((result) => {
-                if (result.success && result.returnData && result.returnData !== '0x') {
-                    try {
-                        return iface.decodeFunctionResult('balanceOf', result.returnData)[0];
-                    }
-                    catch {
-                        return 0n;
-                    }
-                }
-                return 0n;
-            });
-        }
-        catch {
-            // ✅ 回退：并行调用（如果 Multicall3 失败）
-            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);
-        }
-    }
-}
-/**
- * 通过模拟交易获取 ERC20 转账的最小 Gas Limit
- * ✅ 使用 eth_estimateGas 预估实际需要的 gas，然后加一个小的缓冲量
- *
- * @param provider - Provider 实例
- * @param tokenAddress - ERC20 代币地址
- * @param from - 发送方地址
- * @param to - 接收方地址
- * @param amount - 转账金额（wei）
- * @param bufferPercent - 缓冲百分比（默认 5%）
- * @returns 预估的 gas limit
- */
-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
-        });
-        // 添加缓冲量（默认 5%）
-        const buffer = (estimatedGas * BigInt(bufferPercent)) / 100n;
-        const finalGas = estimatedGas + buffer;
-        console.log(`[estimateErc20TransferGas] 预估 gas: ${estimatedGas}, 最终 gas limit: ${finalGas} (+${bufferPercent}%)`);
-        return finalGas;
-    }
-    catch (error) {
-        console.warn(`[estimateErc20TransferGas] 预估失败，使用默认值:`, error);
-        // 回退到默认值
-        return 52000n;
-    }
-}
-/**
- * 批量预估多个 ERC20 转账的 Gas Limit
- * ✅ 选取最大值作为统一的 gas limit（确保所有转账都能成功）
- */
-export async function estimateMaxErc20TransferGas(provider, tokenAddress, from, recipients, amounts, bufferPercent = 5) {
-    if (recipients.length === 0)
-        return 52000n;
-    // 为了减少 RPC 调用，最多预估前 3 个和最后 1 个
-    const sampleIndices = [];
-    sampleIndices.push(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)));
-        // 取最大值
-        const maxGas = estimates.reduce((max, gas) => gas > max ? gas : max, 0n);
-        console.log(`[estimateMaxErc20TransferGas] 样本数: ${uniqueIndices.length}, 最大 gas limit: ${maxGas}`);
-        return maxGas;
-    }
-    catch (error) {
-        console.warn(`[estimateMaxErc20TransferGas] 批量预估失败，使用默认值:`, error);
-        return 52000n;
-    }
-}
-/**
- * 计算 Gas Limit
- * - 原生代币转账：
- *   - BSC: 21000 gas（固定）
- *   - XLayer: 50000 gas（EIP-7702 授权地址需要更多 gas）
- * - ERC20 标准 transfer：约 45000-55000 gas，使用 55000 作为安全值
- *
- * ✅ 优化：降低 ERC20 gas limit，减少中转钱包 BNB 残留
- * ✅ XLayer 特殊处理：EIP-7702 授权的地址接收 OKB 时会触发 delegate 代码，需要更多 gas
- */
-export function calculateGasLimit(config, isNative, hasHops, hopCount = 0) {
-    if (config.gasLimit !== undefined) {
-        return BigInt(config.gasLimit);
-    }
-    // ✅ XLayer 链（chainId=196）原生代币需要更多 gas（EIP-7702 delegate 执行）
-    const isXLayer = config.chainId === 196;
-    // ✅ 原生代币: BSC 21000, XLayer 50000（EIP-7702 安全）
-    // ✅ ERC20 标准 transfer: 48000（USDT 最低约 46815）
-    const baseGas = isNative
-        ? (isXLayer ? 50000 : 21000)
-        : 46815;
-    // ✅ 多跳时只需要累加单次转账的 gas，不需要额外乘数
-    // 每个中转钱包只执行一笔 transfer
-    if (hasHops && hopCount > 0) {
-        // 多跳场景：返回单次转账的 gas limit（中转钱包只执行一笔交易）
-        // 这里不累加，因为每个中转钱包独立执行
-        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;
-}