four-flap-meme-sdk 1.3.80 → 1.3.82

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.d.ts

@@ -21,5 +21,6 @@ export type ApproveFourTokenManagerBatchResult = {
  * ✅ 不需要 Merkle API Key，使用普通 RPC 即可
  * ✅ 专门用于授权给 TokenManagerOriginal 合约
  * ✅ 用于 fourBatchPrivateSell 和 fourBatchSellWithBundleMerkle
+ * ✅ 优化：并行获取 gasPrice、decimals、allowances
  */
 export declare function approveFourTokenManagerBatch(params: ApproveFourTokenManagerBatchParams): Promise<ApproveFourTokenManagerBatchResult>;

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

@@ -15,6 +15,7 @@ const ERC20_ABI = [
  * ✅ 不需要 Merkle API Key，使用普通 RPC 即可
  * ✅ 专门用于授权给 TokenManagerOriginal 合约
  * ✅ 用于 fourBatchPrivateSell 和 fourBatchSellWithBundleMerkle
+ * ✅ 优化：并行获取 gasPrice、decimals、allowances
  */
 export async function approveFourTokenManagerBatch(params) {
     const { privateKeys, tokenAddress, amounts, config } = params;
@@ -28,27 +29,25 @@ export async function approveFourTokenManagerBatch(params) {
         chainId: chainId,
         name: 'BSC'
     });
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
-    // ✅ 优化：如果所有金额都是 'max'，则不需要查询 decimals
-    const allMax = amounts.every(a => a === 'max');
-    let decimals = 18; // 默认值
-    if (!allMax) {
-        try {
-            const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-            decimals = await tokenContract.decimals();
-        }
-        catch (error) {
-            throw new Error(`查询代币 decimals 失败: ${error.message}`);
-        }
-    }
     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));
-    // ✅ 检查是否有非 'max' 的授权
-    const hasNonMaxAmount = amounts.some(a => a !== 'max');
-    if (hasNonMaxAmount) {
-    }
-    // 检查现有授权，过滤掉已经足够的
-    const allowances = await batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr);
     // 只授权不足的
     // ✅ 策略：如果授权额度 < MaxUint256 / 2n，就重新授权（确保授权足够大）
     const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
@@ -64,10 +63,7 @@ export async function approveFourTokenManagerBatch(params) {
             message: '所有钱包已授权，无需重复授权'
         };
     }
-    // 构建授权交易
-    const needApprovalTokens = needApproval.map(w => new ethers.Contract(tokenAddress, ERC20_ABI, w));
-    const unsignedApprovals = await Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i])));
-    // 使用前端传入的 gasLimit，否则使用默认值
+    // ✅ 优化：计算 gasLimit（不需要 RPC）
     const getGasLimit = (cfg) => {
         if (cfg.gasLimit)
             return BigInt(cfg.gasLimit);
@@ -76,9 +72,15 @@ export async function approveFourTokenManagerBatch(params) {
         return 60000n; // 默认授权 gas limit
     };
     const finalGasLimit = getGasLimit(config);
-    // 签名授权交易
+    const txType = getTxType(config);
+    // ✅ 优化：并行获取 nonces 和构建未签名交易
     const nonceManager = new NonceManager(provider);
-    const nonces = await Promise.all(needApproval.map(w => nonceManager.getNextNonce(w)));
+    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,
@@ -86,14 +88,14 @@ export async function approveFourTokenManagerBatch(params) {
         gasLimit: finalGasLimit,
         gasPrice,
         chainId,
-        type: getTxType(config)
+        type: txType
     })));
     nonceManager.clearTemp();
     try {
-        // 广播所有授权交易
+        // ✅ 并行广播所有授权交易
         const txResponses = await Promise.all(signedTxs.map(tx => provider.broadcastTransaction(tx)));
         const txHashes = txResponses.map(r => r.hash);
-        // 等待所有授权交易确认（至少1个确认）
+        // ✅ 并行等待所有授权交易确认（至少1个确认）
         await Promise.all(txResponses.map(tx => tx.wait(1)));
         return {
             success: true,

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

@@ -1,8 +1,16 @@
 import { JsonRpcProvider } from 'ethers';
 import type { AmountLike } from './types.js';
-export declare function getErc20DecimalsMerkle(provider: JsonRpcProvider, token: string): Promise<number>;
+/**
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，使用 provider._network 或传入 chainId
+ */
+export declare function getErc20DecimalsMerkle(provider: JsonRpcProvider, token: string, chainId?: number): Promise<number>;
 export declare function generateHopWallets(recipientCount: number, hopCount: number | number[]): string[][] | 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[]>;
 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,9 +1,14 @@
 import { ethers, Wallet } from 'ethers';
 // 内部缓存：ERC20 小数位
 const decimalsCache = new Map();
-export async function getErc20DecimalsMerkle(provider, token) {
-    const network = await provider.getNetwork();
-    const key = `${network.chainId}_${token.toLowerCase()}`;
+/**
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，使用 provider._network 或传入 chainId
+ */
+export async function getErc20DecimalsMerkle(provider, token, chainId) {
+    // ✅ 优化：优先使用传入的 chainId，其次使用 provider 内部缓存的 network
+    const resolvedChainId = chainId ?? (provider._network?.chainId ? Number(provider._network.chainId) : 56);
+    const key = `${resolvedChainId}_${token.toLowerCase()}`;
     if (decimalsCache.has(key))
         return decimalsCache.get(key);
     try {
@@ -44,18 +49,49 @@ export function normalizeAmounts(recipients, amount, amounts) {
     }
     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 = '0xcA11bde05977b3631167028862bE2a173976CA11';
+    const MULTICALL3_ABI = [
+        'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)',
+        'function getEthBalance(address addr) view returns (uint256 balance)' // ✅ 新增：原生代币余额查询
+    ];
+    const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
     if (!tokenAddress) {
-        return Promise.all(addresses.map(addr => provider.getBalance(addr).catch(() => 0n)));
+        // ✅ 优化：原生代币使用 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 {
-        const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
-        const MULTICALL3_ABI = [
-            'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)'
-        ];
-        const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+        // ERC20 余额：使用 Multicall3 批量获取
         const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
         const iface = new ethers.Interface(ERC20_ABI);
         const calls = addresses.map(addr => ({
@@ -66,13 +102,19 @@ export async function batchGetBalances(provider, addresses, tokenAddress) {
         try {
             const results = await multicall.aggregate3(calls);
             return results.map((result) => {
-                if (result.success) {
-                    return iface.decodeFunctionResult('balanceOf', result.returnData)[0];
+                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])

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

@@ -2,22 +2,26 @@ import { FourPrivateBuySignParams, FourPrivateSellSignParams, FourPrivateTransac
 /**
  * 私有购买（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonce
  */
 export declare function fourPrivateBuyMerkle(params: FourPrivateBuySignParams): Promise<FourPrivateTransactionResult>;
 /**
  * 私有卖出（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动检查授权，智能处理授权+卖出
+ * ✅ 优化：并行获取 gasPrice、allowance、nonce
  */
 export declare function fourPrivateSellMerkle(params: FourPrivateSellSignParams): Promise<FourPrivateTransactionResult>;
 /**
  * 批量私有购买（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonces，批量构建交易
  */
 export declare function fourBatchPrivateBuyMerkle(params: FourBatchPrivateBuySignParams): Promise<FourBatchPrivateMerkleResult>;
 /**
  * 批量私有卖出（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动包含授权交易，无需前端单独调用
+ * ✅ 优化：并行获取所有查询数据，批量获取 nonces
  */
 export declare function fourBatchPrivateSellMerkle(params: FourBatchPrivateSellSignParams): Promise<FourBatchPrivateMerkleResult>;