four-flap-meme-sdk 1.3.81 → 1.3.82

package/dist/flap/portal-bundle-merkle/private.js

@@ -1,6 +1,6 @@
 import { ethers, Wallet } from 'ethers';
 import { MerkleClient } from '../../clients/merkle.js';
-import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
+import { getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { FLAP_PORTAL_ADDRESSES } from '../constants.js';
 import { CHAIN_ID_MAP, PORTAL_ABI, getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
@@ -13,24 +13,26 @@ export async function flapPrivateBuyMerkle(params) {
     const { chainId, provider } = createMerkleContext(chain, config);
     const wallet = new Wallet(privateKey, provider);
     const portalAddr = FLAP_PORTAL_ADDRESSES[chain];
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const originalAmountWei = ethers.parseEther(amountIn);
     // ✅ 利润提取配置
     const extractProfit = shouldExtractProfit(config);
     const { actualAmountWei, profitWei } = splitBuyAmount(originalAmountWei, extractProfit, config);
     const minAmountOut = parseMinOutput(minOutputAmount);
-    const signedTxs = [];
     const portal = new ethers.Contract(portalAddr, PORTAL_ABI, wallet);
-    const unsigned = await portal.swapExactInput.populateTransaction({
-        inputToken: ZERO_ADDRESS,
-        outputToken: tokenAddress,
-        inputAmount: actualAmountWei, // ✅ 使用扣除利润后的金额
-        minOutputAmount: minAmountOut,
-        permitData: '0x',
-    }, { value: actualAmountWei } // ✅ 使用扣除利润后的金额
-    );
+    // ✅ 并行获取 gasPrice、nonce 和构建未签名交易
+    const [gasPrice, currentNonce, unsigned] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        wallet.getNonce(),
+        portal.swapExactInput.populateTransaction({
+            inputToken: ZERO_ADDRESS,
+            outputToken: tokenAddress,
+            inputAmount: actualAmountWei,
+            minOutputAmount: minAmountOut,
+            permitData: '0x',
+        }, { value: actualAmountWei })
+    ]);
     const gasLimit = resolveGasLimit(config.gasLimitMultiplier);
-    const currentNonce = await wallet.getNonce();
+    const signedTxs = [];
     signedTxs.push(await wallet.signTransaction({
         ...unsigned,
         from: wallet.address,
@@ -39,7 +41,7 @@ export async function flapPrivateBuyMerkle(params) {
         gasPrice,
         chainId,
         type: getTxType(config),
-        value: actualAmountWei // ✅ 使用扣除利润后的金额
+        value: actualAmountWei
     }));
     await appendSingleProfitTransfer({
         extractProfit,
@@ -61,11 +63,15 @@ export async function flapPrivateSellMerkle(params) {
     const { chainId, provider } = createMerkleContext(chain, config);
     const wallet = new Wallet(privateKey, provider);
     const portalAddr = FLAP_PORTAL_ADDRESSES[chain];
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const amountWei = ethers.parseUnits(amount, 18);
-    // ✅ 自动获取报价以计算预期收益和利润
     const portal = new ethers.Contract(portalAddr, PORTAL_ABI, wallet);
-    const { quotedOutput, minOut } = await resolveSingleSellOutputs(portal, tokenAddress, amountWei, minOutputAmount);
+    // ✅ 并行获取 gasPrice、nonce 和报价
+    const [gasPrice, currentNonce, { quotedOutput, minOut }] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        wallet.getNonce(),
+        resolveSingleSellOutputs(portal, tokenAddress, amountWei, minOutputAmount)
+    ]);
+    // 构建未签名交易
     const unsigned = await portal.swapExactInput.populateTransaction({
         inputToken: tokenAddress,
         outputToken: ZERO_ADDRESS,
@@ -75,7 +81,6 @@ export async function flapPrivateSellMerkle(params) {
     });
     const gasLimit = resolveGasLimit(config.gasLimitMultiplier);
     const signedTxs = [];
-    const currentNonce = await wallet.getNonce();
     signedTxs.push(await wallet.signTransaction({
         ...unsigned,
         from: wallet.address,
@@ -107,29 +112,35 @@ export async function flapBatchPrivateBuyMerkle(params) {
     }
     const { chainId, provider } = createMerkleContext(chain, config);
     const portalAddr = FLAP_PORTAL_ADDRESSES[chain];
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
-    const signedTxs = [];
-    const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map(k => new Wallet(k, provider));
     const originalAmountsWei = amountsIn.map(a => ethers.parseEther(a));
     // ✅ 利润提取配置
     const extractProfit = shouldExtractProfit(config);
     const { totalProfit, remainingAmounts } = calculateBatchProfit(originalAmountsWei, config);
-    const actualAmountsWei = remainingAmounts; // 扣除利润后用于购买的金额
+    const actualAmountsWei = remainingAmounts;
     const maxFundsIndex = findMaxIndex(originalAmountsWei);
     const minOuts = resolveBatchMinOutputs(minOutputAmounts, wallets.length);
     const portals = wallets.map(w => new ethers.Contract(portalAddr, PORTAL_ABI, w));
-    const unsignedList = await Promise.all(portals.map((portal, i) => portal.swapExactInput.populateTransaction({
-        inputToken: '0x0000000000000000000000000000000000000000',
-        outputToken: tokenAddress,
-        inputAmount: actualAmountsWei[i], // ✅ 使用扣除利润后的金额
-        minOutputAmount: minOuts[i],
-        permitData: '0x',
-    }, { value: actualAmountsWei[i] } // ✅ 使用扣除利润后的金额
-    )));
+    // ✅ 并行获取 gasPrice、所有 nonces 和构建未签名交易
+    const [gasPrice, initialNonces, unsignedList] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        Promise.all(wallets.map(w => w.getNonce())),
+        Promise.all(portals.map((portal, i) => portal.swapExactInput.populateTransaction({
+            inputToken: ZERO_ADDRESS,
+            outputToken: tokenAddress,
+            inputAmount: actualAmountsWei[i],
+            minOutputAmount: minOuts[i],
+            permitData: '0x',
+        }, { value: actualAmountsWei[i] })))
+    ]);
+    // ✅ 为需要支付利润的钱包预留额外 nonce
+    const nonces = initialNonces.map((n, i) => {
+        // 如果这个钱包需要支付利润，它的主交易 nonce 不变，利润交易用 nonce+1
+        return n;
+    });
     const gasLimit = resolveGasLimit(config.gasLimitMultiplier);
     const gasLimits = new Array(wallets.length).fill(gasLimit);
-    const nonces = await allocateProfitNonces(wallets, extractProfit, maxFundsIndex, totalProfit, nonceManager);
+    // ✅ 并行签名所有交易
     const signedList = await signBatchTransactions({
         unsignedList,
         wallets,
@@ -140,20 +151,21 @@ export async function flapBatchPrivateBuyMerkle(params) {
         config,
         values: actualAmountsWei
     });
-    signedTxs.push(...signedList);
-    await appendBatchProfitTransfer({
-        extractProfit,
-        totalProfit,
-        wallets,
-        maxIndex: maxFundsIndex,
-        nonces,
-        gasPrice,
-        chainId,
-        config,
-        signedTxs
-    });
-    // ✅ 清理临时 nonce 缓存
-    nonceManager.clearTemp();
+    const signedTxs = [...signedList];
+    // 添加利润交易（使用 nonce + 1）
+    if (extractProfit && totalProfit > 0n && maxFundsIndex >= 0) {
+        const profitNonce = initialNonces[maxFundsIndex] + 1;
+        const profitTx = await wallets[maxFundsIndex].signTransaction({
+            to: getProfitRecipient(),
+            value: totalProfit,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId,
+            type: getTxType(config)
+        });
+        signedTxs.push(profitTx);
+    }
     return { signedTransactions: signedTxs };
 }
 /**
@@ -166,34 +178,30 @@ export async function flapBatchPrivateSellMerkle(params) {
     }
     const { chainId, provider } = createMerkleContext(chain, config);
     const portalAddr = FLAP_PORTAL_ADDRESSES[chain];
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
-    const signedTxs = [];
-    const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map(k => new Wallet(k, provider));
     const amountsWei = amounts.map(a => ethers.parseUnits(a, 18));
-    // ✅ 自动获取报价以计算预期收益和利润
     const portal = new ethers.Contract(portalAddr, PORTAL_ABI, provider);
-    // 并行获取所有报价
-    const quotedOutputs = await Promise.all(amountsWei.map(amount => 
-    // ✅ 使用 staticCall 调用 view 函数
-    portal.quoteExactInput.staticCall({
-        inputToken: tokenAddress,
-        outputToken: '0x0000000000000000000000000000000000000000',
-        inputAmount: amount
-    }).catch(() => 0n) // 如果报价失败，返回 0n
-    ));
-    // ✅ 使用报价结果或用户提供的 minOutputAmounts
+    const portals = wallets.map(w => new ethers.Contract(portalAddr, PORTAL_ABI, w));
+    // ✅ 并行获取 gasPrice、所有 nonces 和所有报价
+    const [gasPrice, initialNonces, quotedOutputs] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        Promise.all(wallets.map(w => w.getNonce())),
+        Promise.all(amountsWei.map(amount => portal.quoteExactInput.staticCall({
+            inputToken: tokenAddress,
+            outputToken: ZERO_ADDRESS,
+            inputAmount: amount
+        }).catch(() => 0n)))
+    ]);
+    // 计算 minOuts
     let minOuts;
     if (minOutputAmounts && minOutputAmounts.length === wallets.length) {
-        // 用户提供了 minOutputAmounts，优先使用
         minOuts = minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
     }
     else {
-        // 使用报价结果作为 minOutputAmount（保守起见，使用 95% 的报价金额）
         minOuts = quotedOutputs.map(quoted => quoted * 95n / 100n);
     }
-    const portals = wallets.map(w => new ethers.Contract(portalAddr, PORTAL_ABI, w));
-    const unsignedList = await Promise.all(portals.map((portal, i) => portal.swapExactInput.populateTransaction({
+    // ✅ 并行构建未签名交易
+    const unsignedList = await Promise.all(portals.map((p, i) => p.swapExactInput.populateTransaction({
         inputToken: tokenAddress,
         outputToken: ZERO_ADDRESS,
         inputAmount: amountsWei[i],
@@ -204,29 +212,31 @@ export async function flapBatchPrivateSellMerkle(params) {
     const { totalProfit, maxRevenueIndex } = summarizeSellProfits(quotedOutputs, extractProfit, config);
     const gasLimit = resolveGasLimit(config.gasLimitMultiplier);
     const gasLimits = new Array(wallets.length).fill(gasLimit);
-    const nonces = await allocateProfitNonces(wallets, extractProfit, maxRevenueIndex, totalProfit, nonceManager);
+    // ✅ 并行签名所有卖出交易
     const signedList = await signBatchTransactions({
         unsignedList,
         wallets,
-        nonces,
+        nonces: initialNonces,
         gasLimits,
         gasPrice,
         chainId,
         config
     });
-    signedTxs.push(...signedList);
-    await appendBatchProfitTransfer({
-        extractProfit,
-        totalProfit,
-        wallets,
-        maxIndex: maxRevenueIndex,
-        nonces,
-        gasPrice,
-        chainId,
-        config,
-        signedTxs
-    });
-    nonceManager.clearTemp();
+    const signedTxs = [...signedList];
+    // 添加利润交易（使用 nonce + 1）
+    if (extractProfit && totalProfit > 0n && maxRevenueIndex >= 0) {
+        const profitNonce = initialNonces[maxRevenueIndex] + 1;
+        const profitTx = await wallets[maxRevenueIndex].signTransaction({
+            to: getProfitRecipient(),
+            value: totalProfit,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId,
+            type: getTxType(config)
+        });
+        signedTxs.push(profitTx);
+    }
     return { signedTransactions: signedTxs };
 }
 // ==================== 内部工具函数 ====================
@@ -354,20 +364,6 @@ function findMaxIndex(values) {
     }
     return maxIndex;
 }
-async function allocateProfitNonces(wallets, extractProfit, maxIndex, totalProfit, nonceManager) {
-    const nonces = [];
-    for (let i = 0; i < wallets.length; i++) {
-        if (extractProfit && totalProfit > 0n && i === maxIndex) {
-            const [nonce] = await nonceManager.getNextNonceBatch(wallets[i], 2);
-            nonces.push(nonce);
-        }
-        else {
-            const nonce = await nonceManager.getNextNonce(wallets[i]);
-            nonces.push(nonce);
-        }
-    }
-    return nonces;
-}
 async function signBatchTransactions({ unsignedList, wallets, nonces, gasLimits, gasPrice, chainId, config, values }) {
     return await Promise.all(unsignedList.map((unsigned, i) => {
         const value = values ? values[i] : unsigned.value;
@@ -383,22 +379,6 @@ async function signBatchTransactions({ unsignedList, wallets, nonces, gasLimits,
         });
     }));
 }
-async function appendBatchProfitTransfer({ extractProfit, totalProfit, wallets, maxIndex, nonces, gasPrice, chainId, config, signedTxs }) {
-    if (!extractProfit || totalProfit === 0n || maxIndex < 0 || wallets.length === 0) {
-        return;
-    }
-    const profitNonce = (nonces[maxIndex] ?? 0) + 1;
-    const profitTx = await wallets[maxIndex].signTransaction({
-        to: getProfitRecipient(),
-        value: totalProfit,
-        nonce: profitNonce,
-        gasPrice,
-        gasLimit: 21000n,
-        chainId,
-        type: getTxType(config)
-    });
-    signedTxs.push(profitTx);
-}
 function summarizeSellProfits(quotedOutputs, extractProfit, config) {
     let totalProfit = 0n;
     let maxRevenueIndex = -1;

package/dist/utils/airdrop-sweep.js

@@ -39,10 +39,10 @@ export async function disperseWithBundle(params) {
     const signedTxs = [];
     if (isNative) {
         const baseNonce = await provider.getTransactionCount(wallet.address, 'pending');
-        for (let i = 0; i < recipients.length; i++) {
-            const to = recipients[i];
+        // ✅ 并行签名所有交易
+        const signedTxList = await Promise.all(recipients.map(async (to, i) => {
             const amountWei = ethers.parseEther(effAmounts[i]);
-            const tx = await wallet.signTransaction({
+            return wallet.signTransaction({
                 to,
                 value: amountWei,
                 nonce: baseNonce + i,
@@ -51,18 +51,21 @@ export async function disperseWithBundle(params) {
                 chainId,
                 type: 0
             });
-            signedTxs.push(tx);
-        }
+        }));
+        signedTxs.push(...signedTxList);
     }
     else {
-        const decimals = await getErc20Decimals(provider, tokenAddress);
+        // ✅ 并行获取 decimals 和 nonce
+        const [decimals, baseNonce] = await Promise.all([
+            getErc20Decimals(provider, tokenAddress),
+            provider.getTransactionCount(wallet.address, 'pending')
+        ]);
         const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-        const baseNonce = await provider.getTransactionCount(wallet.address, 'pending');
-        for (let i = 0; i < recipients.length; i++) {
-            const to = recipients[i];
+        // ✅ 并行签名所有交易
+        const signedTxList = await Promise.all(recipients.map(async (to, i) => {
             const amountWei = ethers.parseUnits(effAmounts[i], decimals);
             const data = iface.encodeFunctionData('transfer', [to, amountWei]);
-            const tx = await wallet.signTransaction({
+            return wallet.signTransaction({
                 to: tokenAddress,
                 data,
                 value: 0n,
@@ -72,8 +75,8 @@ export async function disperseWithBundle(params) {
                 chainId,
                 type: 0
             });
-            signedTxs.push(tx);
-        }
+        }));
+        signedTxs.push(...signedTxList);
     }
     // ✅ 只返回签名交易，不提交到 Bundle
     return { signedTransactions: signedTxs };
@@ -104,89 +107,96 @@ export async function sweepWithBundle(params) {
     };
     const ratio = clampRatio(ratioPct);
     if (isNative) {
-        for (let i = 0; i < sourcePrivateKeys.length; i++) {
-            const w = new ethers.Wallet(sourcePrivateKeys[i], provider);
-            let toSend = 0n;
-            try {
-                const bal = await provider.getBalance(w.address);
-                const gasCost = nativeGasLimit * gasPrice;
-                if (ratio !== undefined) {
-                    const want = (bal * BigInt(ratio)) / 100n;
-                    const maxSendable = bal > gasCost ? (bal - gasCost) : 0n;
-                    toSend = want > maxSendable ? maxSendable : want;
-                }
-                else if (amount && amount.trim().length > 0) {
-                    const amountWei = ethers.parseEther(amount);
-                    const needed = amountWei + gasCost;
-                    if (!skipIfInsufficient || bal >= needed)
-                        toSend = amountWei;
-                }
+        // ✅ 并行处理所有源钱包
+        const wallets = sourcePrivateKeys.map(pk => new ethers.Wallet(pk, provider));
+        const gasCost = nativeGasLimit * gasPrice;
+        // 并行获取所有余额和 nonce
+        const [balances, nonces] = await Promise.all([
+            Promise.all(wallets.map(w => provider.getBalance(w.address).catch(() => 0n))),
+            Promise.all(wallets.map(w => provider.getTransactionCount(w.address, 'pending')))
+        ]);
+        // 计算每个钱包的发送金额
+        const sendAmounts = balances.map(bal => {
+            if (ratio !== undefined) {
+                const want = (bal * BigInt(ratio)) / 100n;
+                const maxSendable = bal > gasCost ? (bal - gasCost) : 0n;
+                return want > maxSendable ? maxSendable : want;
             }
-            catch {
-                // 读取失败：保守不发送
-                toSend = 0n;
+            else if (amount && amount.trim().length > 0) {
+                const amountWei = ethers.parseEther(amount);
+                const needed = amountWei + gasCost;
+                if (!skipIfInsufficient || bal >= needed)
+                    return amountWei;
             }
-            if (toSend <= 0n)
-                continue;
-            const nonce = await provider.getTransactionCount(w.address, 'pending');
-            const tx = await w.signTransaction({
-                to: target,
-                value: toSend,
-                nonce,
-                gasPrice,
-                gasLimit: nativeGasLimit,
-                chainId,
-                type: 0
-            });
-            signedTxs.push(tx);
-        }
+            return 0n;
+        });
+        // 并行签名所有有效交易
+        const validIndices = sendAmounts.map((amt, i) => amt > 0n ? i : -1).filter(i => i >= 0);
+        const signedTxList = await Promise.all(validIndices.map(i => wallets[i].signTransaction({
+            to: target,
+            value: sendAmounts[i],
+            nonce: nonces[i],
+            gasPrice,
+            gasLimit: nativeGasLimit,
+            chainId,
+            type: 0
+        })));
+        signedTxs.push(...signedTxList);
     }
     else {
-        const decimals = await getErc20Decimals(provider, tokenAddress);
+        const wallets = sourcePrivateKeys.map(pk => new ethers.Wallet(pk, provider));
         const iface = new ethers.Interface(['function balanceOf(address) view returns (uint256)', 'function transfer(address,uint256) returns (bool)']);
-        for (let i = 0; i < sourcePrivateKeys.length; i++) {
-            const w = new ethers.Wallet(sourcePrivateKeys[i], provider);
-            let toSend = 0n;
-            try {
-                const balData = iface.encodeFunctionData('balanceOf', [w.address]);
-                const balRaw = await provider.call({ to: tokenAddress, data: balData });
-                const [bal] = iface.decodeFunctionResult('balanceOf', balRaw);
-                if (ratio !== undefined) {
-                    toSend = (bal * BigInt(ratio)) / 100n;
-                }
-                else if (amount && amount.trim().length > 0) {
-                    toSend = ethers.parseUnits(amount, decimals);
-                }
-            }
-            catch {
-                toSend = 0n;
-            }
-            if (toSend <= 0n)
-                continue;
-            if (skipIfInsufficient) {
+        // ✅ 并行获取 decimals、所有代币余额和 nonce
+        const [decimals, balanceResults, nonces] = await Promise.all([
+            getErc20Decimals(provider, tokenAddress),
+            Promise.all(wallets.map(async (w) => {
                 try {
                     const balData = iface.encodeFunctionData('balanceOf', [w.address]);
                     const balRaw = await provider.call({ to: tokenAddress, data: balData });
                     const [bal] = iface.decodeFunctionResult('balanceOf', balRaw);
-                    if (bal < toSend)
-                        continue;
+                    return bal;
+                }
+                catch {
+                    return 0n;
                 }
-                catch { }
+            })),
+            Promise.all(wallets.map(w => provider.getTransactionCount(w.address, 'pending')))
+        ]);
+        // 计算每个钱包的发送金额
+        const sendAmounts = balanceResults.map(bal => {
+            if (ratio !== undefined) {
+                return (bal * BigInt(ratio)) / 100n;
+            }
+            else if (amount && amount.trim().length > 0) {
+                const amountWei = ethers.parseUnits(amount, decimals);
+                if (!skipIfInsufficient || bal >= amountWei)
+                    return amountWei;
             }
-            const data = iface.encodeFunctionData('transfer', [target, toSend]);
-            const nonce = await provider.getTransactionCount(w.address, 'pending');
-            const tx = await w.signTransaction({
+            return 0n;
+        });
+        // 过滤余额不足的钱包
+        const validIndices = sendAmounts.map((amt, i) => {
+            if (amt <= 0n)
+                return -1;
+            if (skipIfInsufficient && balanceResults[i] < amt)
+                return -1;
+            return i;
+        }).filter(i => i >= 0);
+        // 并行签名所有有效交易
+        const signedTxList = await Promise.all(validIndices.map(i => {
+            const data = iface.encodeFunctionData('transfer', [target, sendAmounts[i]]);
+            return wallets[i].signTransaction({
                 to: tokenAddress,
                 data,
                 value: 0n,
-                nonce,
+                nonce: nonces[i],
                 gasPrice,
                 gasLimit: transferGasLimit,
                 chainId,
                 type: 0
             });
-            signedTxs.push(tx);
-        }
+        }));
+        signedTxs.push(...signedTxList);
     }
     // ✅ 只返回签名交易，不提交到 Bundle
     return { signedTransactions: signedTxs };

package/dist/utils/erc20.d.ts

@@ -75,6 +75,7 @@ export declare function ensureFlapSellApproval(chain: 'BSC' | 'BASE' | 'XLAYER'
 export declare function ensureFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, privateKeys: string[], token: string, required?: bigint): Promise<EnsureAllowanceBatchItemResult[]>;
 /**
  * 批量检查 Flap Protocol 授权状态（默认按上限 2^256-1 判断）
+ * ✅ 使用 Multicall3 批量查询，减少 RPC 调用次数
  */
 export declare function checkFlapSellApprovalBatch(chain: 'BSC' | 'BASE' | 'XLAYER' | 'MORPH' | 'MONAD', rpcUrl: string, token: string, owners: string[], required?: bigint): Promise<Array<{
     owner: string;

package/dist/utils/erc20.js

@@ -216,18 +216,23 @@ export async function ensureFlapSellApproval(chain, rpcUrl, privateKey, token, o
  * @returns 每个地址的授权结果（包含 owner 与交易回执等信息）
  */
 export async function ensureFlapSellApprovalBatch(chain, rpcUrl, privateKeys, token, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
-    const results = [];
-    for (const pk of privateKeys || []) {
+    if (!privateKeys || privateKeys.length === 0)
+        return [];
+    // ✅ 并行处理所有授权
+    const results = await Promise.all(privateKeys.map(async (pk) => {
         const owner = new Wallet(pk).address;
         const r = await ensureFlapSellApproval(chain, rpcUrl, pk, token, owner, required);
-        results.push({ owner, ...r });
-    }
+        return { owner, ...r };
+    }));
     return results;
 }
 /**
  * 批量检查 Flap Protocol 授权状态（默认按上限 2^256-1 判断）
+ * ✅ 使用 Multicall3 批量查询，减少 RPC 调用次数
  */
 export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, required = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
+    if (!owners || owners.length === 0)
+        return [];
     const proxyAddresses = {
         BSC: ADDRESSES.BSC.FlapPortal,
         BASE: ADDRESSES.BASE.FlapPortal,
@@ -236,22 +241,19 @@ export async function checkFlapSellApprovalBatch(chain, rpcUrl, token, owners, r
         MONAD: ADDRESSES.MONAD.FlapPortal,
     };
     const provider = new JsonRpcProvider(rpcUrl);
-    // ✅ 验证 token 和代理合约地址
-    await validateContractAddress(provider, token, 'Token');
-    await validateContractAddress(provider, proxyAddresses[chain], `Flap Portal (${chain})`);
-    const erc20 = new Contract(token, ERC20_ABI, provider);
-    const out = [];
-    for (const owner of owners || []) {
-        let current;
-        try {
-            current = await erc20.allowance(owner, proxyAddresses[chain]);
-        }
-        catch (error) {
-            throw new Error(`❌ 调用 allowance 失败（Token 可能不是 ERC20）: ${error.message}`);
-        }
-        out.push({ owner, isApproved: current >= required, currentAllowance: current, requiredAllowance: required });
-    }
-    return out;
+    // ✅ 并行验证 token 和代理合约地址
+    await Promise.all([
+        validateContractAddress(provider, token, 'Token'),
+        validateContractAddress(provider, proxyAddresses[chain], `Flap Portal (${chain})`)
+    ]);
+    // ✅ 使用 batchCheckAllowances 批量查询（Multicall3）
+    const allowances = await batchCheckAllowances(provider, token, owners, proxyAddresses[chain]);
+    return owners.map((owner, i) => ({
+        owner,
+        isApproved: allowances[i] >= required,
+        currentAllowance: allowances[i],
+        requiredAllowance: required
+    }));
 }
 /**
  * 使用 Multicall3 批量查询 ERC20 授权额度