four-flap-meme-sdk 2.2.0 → 2.2.2

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

@@ -1,4 +1,48 @@
+import { JsonRpcProvider } from 'ethers';
+import type { AmountLike } from './types.js';
+import type { GeneratedWallet } from '../../utils/wallet.js';
 /**
- * @deprecated 实现已迁移至 bundle-core/internal.ts，此处仅 re-export 保持 import 路径不变。
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，直接使用传入的 chainId
  */
-export { getErc20Decimals, getErc20DecimalsMerkle, generateHopWallets, normalizeAmounts, batchGetBalances, estimateErc20TransferGas, estimateMaxErc20TransferGas, calculateGasLimit, isNativeTokenAddress, } from '../../bundle-core/internal.js';
+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,4 +1,240 @@
+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();
 /**
- * @deprecated 实现已迁移至 bundle-core/internal.ts，此处仅 re-export 保持 import 路径不变。
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，直接使用传入的 chainId
  */
-export { getErc20Decimals, getErc20DecimalsMerkle, generateHopWallets, normalizeAmounts, batchGetBalances, estimateErc20TransferGas, estimateMaxErc20TransferGas, calculateGasLimit, isNativeTokenAddress, } from '../../bundle-core/internal.js';
+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;
+}

package/dist/contracts/tm-bundle-merkle/pancake-proxy.d.ts

@@ -1 +1,28 @@
-export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approveFourPancakeProxy, approveFourPancakeProxyBatch, } from '../../bundle-core/four-meme/pancake-proxy.js';
+/**
+ * PancakeSwap 官方 Router 交易模块
+ *
+ * ✅ 使用官方 PancakeSwap V2/V3 Router（非代理合约）
+ * - V2 Router: 0x10ED43C718714eb63d5aA57B78B54704E256024E
+ * - V3 Router: 0x13f4EA83D0bd40E75C8222255bc855a974568Dd4
+ * - V3 Quoter: 0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997
+ */
+import { FourPancakeProxyBatchBuySignParams, FourPancakeProxyBatchBuyResult, FourPancakeProxyBatchSellSignParams, FourPancakeProxyBatchSellResult, FourPancakeProxyApprovalParams, FourPancakeProxyApprovalBatchParams, FourPancakeProxyApprovalBatchResult } from './types.js';
+/**
+ * ✅ 授权代币给 PancakeSwap Router（根据 routeType 选择 V2/V3）
+ */
+export declare function approveFourPancakeProxy(params: FourPancakeProxyApprovalParams): Promise<{
+    txHash: string;
+    approved: boolean;
+}>;
+/**
+ * ✅ 批量授权代币给 PancakeSwap Router
+ */
+export declare function approveFourPancakeProxyBatch(params: FourPancakeProxyApprovalBatchParams): Promise<FourPancakeProxyApprovalBatchResult>;
+/**
+ * ✅ 使用 PancakeSwap 官方 Router 批量购买代币
+ */
+export declare function fourPancakeProxyBatchBuyMerkle(params: FourPancakeProxyBatchBuySignParams): Promise<FourPancakeProxyBatchBuyResult>;
+/**
+ * ✅ 使用 PancakeSwap 官方 Router 批量卖出代币
+ */
+export declare function fourPancakeProxyBatchSellMerkle(params: FourPancakeProxyBatchSellSignParams): Promise<FourPancakeProxyBatchSellResult>;