four-flap-meme-sdk 1.3.39 → 1.3.40

package/dist/contracts/tm-bundle-merkle/pancake-proxy.js

@@ -303,17 +303,25 @@ export async function fourPancakeProxyBatchBuyMerkle(params) {
     const actualAmountsWei = remainingAmounts; // 扣除利润后用于购买的金额
     const finalGasLimit = getGasLimit(config);
     const nonceManager = new NonceManager(provider);
-    // ✅ 优化：并行获取 gasPrice、tokenDecimals 和 nonces（JSON-RPC 批量请求）
-    const [gasPrice, tokenDecimals, nonces] = await Promise.all([
+    // ✅ 优化：并行获取 gasPrice 和 tokenDecimals
+    const [gasPrice, tokenDecimals] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
-        getTokenDecimals(tokenAddress, provider),
-        nonceManager.getNextNoncesForWallets(buyers) // ✅ 批量获取 nonce
+        getTokenDecimals(tokenAddress, provider)
     ]);
-    // ✅ 如果需要利润转账，预先获取 nonce
-    let profitNonce;
-    if (extractProfit && totalProfit > 0n) {
-        profitNonce = await nonceManager.getNextNonce(buyers[0]);
-    }
+    // ✅ 修复：先计算需要的 nonce 数量，再统一获取
+    // buyers[0] 可能需要 2 个 nonce（买入 + 利润转账）
+    const needProfitTx = extractProfit && totalProfit > 0n;
+    const buyer0NeedCount = needProfitTx ? 2 : 1;
+    // 获取 buyers[0] 的连续 nonces
+    const buyer0Nonces = await nonceManager.getNextNonceBatch(buyers[0], buyer0NeedCount);
+    // 获取其他 buyers 的 nonces（如果有）
+    let otherNonces = [];
+    if (buyers.length > 1) {
+        otherNonces = await nonceManager.getNextNoncesForWallets(buyers.slice(1));
+    }
+    // 组装最终的 nonces 数组
+    const nonces = [buyer0Nonces[0], ...otherNonces];
+    const profitNonce = needProfitTx ? buyer0Nonces[1] : undefined;
     // 计算 minOutputAmounts
     let minOuts;
     if (params.minOutputAmounts && params.minOutputAmounts.length === buyers.length) {
@@ -401,12 +409,11 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     const finalGasLimit = getGasLimit(config);
     const nonceManager = new NonceManager(provider);
     const extractProfit = shouldExtractProfit(config);
-    // ✅ 优化：并行获取 gasPrice、tokenDecimals、allowances 和 nonces（JSON-RPC 批量请求）
-    const [gasPrice, tokenDecimals, allowances, nonces] = await Promise.all([
+    // ✅ 优化：并行获取 gasPrice、tokenDecimals 和 allowances
+    const [gasPrice, tokenDecimals, allowances] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
-        batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress),
-        nonceManager.getNextNoncesForWallets(sellers) // ✅ 批量获取 nonce
+        batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress)
     ]);
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
     // 找出需要授权的钱包索引
@@ -464,7 +471,7 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
         // ✅ minOuts = 0，不设置滑点限制（大额交易更稳定）
         minOuts = quotedOutputs.map(() => 0n);
     }
-    // ✅ 计算利润并找出收益最多的钱包（提前计算，预先获取 nonce）
+    // ✅ 计算利润并找出收益最多的钱包
     let totalProfit = 0n;
     let maxRevenueIndex = 0;
     let maxRevenue = 0n;
@@ -480,10 +487,35 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
             }
         }
     }
-    // ✅ 如果需要利润转账，预先获取 nonce
+    // ✅ 修复：先计算需要的 nonce 数量，再统一获取
+    const needProfitTx = extractProfit && totalProfit > 0n && maxRevenue > 0n;
+    // 分配 nonces：收益最多的钱包可能需要 2 个 nonce（卖出 + 利润转账）
+    let nonces;
     let profitNonce;
-    if (extractProfit && totalProfit > 0n && maxRevenue > 0n) {
-        profitNonce = await nonceManager.getNextNonce(sellers[maxRevenueIndex]);
+    if (needProfitTx) {
+        // 收益最多的钱包需要 2 个连续 nonce
+        const maxRevenueNonces = await nonceManager.getNextNonceBatch(sellers[maxRevenueIndex], 2);
+        // 其他钱包各需要 1 个 nonce
+        const otherSellers = sellers.filter((_, i) => i !== maxRevenueIndex);
+        const otherNonces = otherSellers.length > 0
+            ? await nonceManager.getNextNoncesForWallets(otherSellers)
+            : [];
+        // 组装最终的 nonces 数组（保持原顺序）
+        nonces = [];
+        let otherIdx = 0;
+        for (let i = 0; i < sellers.length; i++) {
+            if (i === maxRevenueIndex) {
+                nonces.push(maxRevenueNonces[0]); // 卖出交易用第一个 nonce
+            }
+            else {
+                nonces.push(otherNonces[otherIdx++]);
+            }
+        }
+        profitNonce = maxRevenueNonces[1]; // 利润交易用第二个 nonce
+    }
+    else {
+        // 不需要利润交易，所有钱包各 1 个 nonce
+        nonces = await nonceManager.getNextNoncesForWallets(sellers);
     }
     // 卖出不需要发送 BNB，只需要 flatFee
     const needBNB = false;

package/dist/flap/portal-bundle-merkle/encryption.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
+/**
+ * 验证公钥格式（Base64）
+ */
+export declare function validatePublicKey(publicKeyBase64: string): boolean;

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

@@ -0,0 +1,146 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 获取全局 crypto 对象（最简单直接的方式）
+ */
+function getCryptoAPI() {
+    // 尝试所有可能的全局对象，优先浏览器环境
+    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
+        (typeof self !== 'undefined' && self.crypto) ||
+        (typeof global !== 'undefined' && global.crypto) ||
+        (typeof globalThis !== 'undefined' && globalThis.crypto);
+    if (!cryptoObj) {
+        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
+            '请确保在 HTTPS 或 localhost 下运行');
+    }
+    return cryptoObj;
+}
+/**
+ * 获取 SubtleCrypto（用于加密操作）
+ */
+function getSubtleCrypto() {
+    const crypto = getCryptoAPI();
+    if (!crypto.subtle) {
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
+        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
+            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
+            '3) 不在无痕/隐私浏览模式下');
+    }
+    return crypto.subtle;
+}
+/**
+ * Base64 转 ArrayBuffer（优先使用浏览器 API）
+ */
+function base64ToArrayBuffer(base64) {
+    // 浏览器环境（优先）
+    if (typeof atob !== 'undefined') {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(base64, 'base64').buffer;
+    }
+    throw new Error('❌ Base64 解码不可用');
+}
+/**
+ * ArrayBuffer 转 Base64（优先使用浏览器 API）
+ */
+function arrayBufferToBase64(buffer) {
+    // 浏览器环境（优先）
+    if (typeof btoa !== 'undefined') {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(buffer).toString('base64');
+    }
+    throw new Error('❌ Base64 编码不可用');
+}
+/**
+ * 生成随机 Hex 字符串
+ */
+function randomHex(length) {
+    const crypto = getCryptoAPI();
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
+    try {
+        // 0. 获取 SubtleCrypto 和 Crypto API
+        const subtle = getSubtleCrypto();
+        const crypto = getCryptoAPI();
+        // 1. 准备数据
+        const payload = {
+            signedTransactions,
+            timestamp: Date.now(),
+            nonce: randomHex(8)
+        };
+        const plaintext = JSON.stringify(payload);
+        // 2. 生成临时 ECDH 密钥对
+        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
+        // 3. 导入服务器公钥
+        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
+        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+        // 4. 派生共享密钥（AES-256）
+        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
+        // 5. AES-GCM 加密
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
+        // 6. 导出临时公钥
+        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
+        // 7. 返回加密包（JSON 格式）
+        return JSON.stringify({
+            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
+            i: arrayBufferToBase64(iv.buffer), // IV
+            d: arrayBufferToBase64(encrypted) // 密文
+        });
+    }
+    catch (error) {
+        throw new Error(`加密失败: ${error?.message || String(error)}`);
+    }
+}
+/**
+ * 验证公钥格式（Base64）
+ */
+export function validatePublicKey(publicKeyBase64) {
+    try {
+        if (!publicKeyBase64)
+            return false;
+        // Base64 字符集验证
+        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
+            return false;
+        // ECDH P-256 公钥固定长度 65 字节（未压缩）
+        // Base64 编码后约 88 字符
+        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/flap/portal-bundle-merkle/pancake-proxy.js

@@ -354,8 +354,8 @@ export async function pancakeProxyBatchSellMerkle(params) {
     const finalGasLimit = getGasLimit(config);
     const extractProfit = shouldExtractProfit(config);
     const nonceManager = new NonceManager(provider);
-    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、allowances、nonces（JSON-RPC 批量请求）
-    const [gasPrice, tokenDecimals, , nonces] = await Promise.all([
+    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、allowances
+    const [gasPrice, tokenDecimals] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
         ensureAllowances({
@@ -363,8 +363,7 @@ export async function pancakeProxyBatchSellMerkle(params) {
             tokenAddress,
             owners: sellers.map(w => w.address),
             spender: ADDRESSES.BSC.PancakeProxy
-        }),
-        nonceManager.getNextNoncesForWallets(sellers) // ✅ 批量获取 nonce
+        })
     ]);
     const amountsWei = sellAmounts.map(amount => ethers.parseUnits(amount, tokenDecimals));
     // ✅ 优化：第二批并行 - resolveSellOutputs 和 buildSellTransactions
@@ -376,6 +375,52 @@ export async function pancakeProxyBatchSellMerkle(params) {
         routeType,
         amountsWei
     });
+    // ✅ 修复：先计算利润和 maxRevenueIndex，再统一分配 nonces
+    let totalProfit = 0n;
+    let maxRevenueIndex = -1;
+    let maxRevenue = 0n;
+    if (extractProfit && quotedOutputs.length > 0) {
+        for (let i = 0; i < sellers.length; i++) {
+            const quoted = quotedOutputs[i];
+            if (quoted > 0n) {
+                const { profit } = calculateProfit(quoted, config);
+                totalProfit += profit;
+                if (quoted > maxRevenue) {
+                    maxRevenue = quoted;
+                    maxRevenueIndex = i;
+                }
+            }
+        }
+    }
+    // ✅ 修复：根据是否需要利润交易，统一分配 nonces
+    const needProfitTx = extractProfit && totalProfit > 0n && maxRevenueIndex >= 0;
+    let nonces;
+    let profitNonce;
+    if (needProfitTx) {
+        // maxRevenueIndex 钱包需要 2 个连续 nonce（卖出 + 利润）
+        const maxRevenueNonces = await nonceManager.getNextNonceBatch(sellers[maxRevenueIndex], 2);
+        // 其他钱包各需要 1 个 nonce
+        const otherSellers = sellers.filter((_, i) => i !== maxRevenueIndex);
+        const otherNonces = otherSellers.length > 0
+            ? await nonceManager.getNextNoncesForWallets(otherSellers)
+            : [];
+        // 组装最终的 nonces 数组（保持原顺序）
+        nonces = [];
+        let otherIdx = 0;
+        for (let i = 0; i < sellers.length; i++) {
+            if (i === maxRevenueIndex) {
+                nonces.push(maxRevenueNonces[0]); // 卖出交易用第一个 nonce
+            }
+            else {
+                nonces.push(otherNonces[otherIdx++]);
+            }
+        }
+        profitNonce = maxRevenueNonces[1]; // 利润交易用第二个 nonce
+    }
+    else {
+        // 不需要利润交易，所有钱包各 1 个 nonce
+        nonces = await nonceManager.getNextNoncesForWallets(sellers);
+    }
     const unsignedSells = await buildSellTransactions({
         routeType,
         params,
@@ -399,16 +444,19 @@ export async function pancakeProxyBatchSellMerkle(params) {
             value: txValue
         });
     }));
-    await appendSellProfitTransfer({
-        extractProfit,
-        quotedOutputs,
-        wallets: sellers,
-        nonceManager,
-        signedTxs,
-        gasPrice,
-        chainId,
-        config
-    });
+    // ✅ 添加利润交易（使用预先分配的 profitNonce）
+    if (needProfitTx && profitNonce !== undefined) {
+        const profitTx = await sellers[maxRevenueIndex].signTransaction({
+            to: getProfitRecipient(),
+            value: totalProfit,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId,
+            type: getTxType(config)
+        });
+        signedTxs.push(profitTx);
+    }
     nonceManager.clearTemp();
     return {
         signedTransactions: signedTxs
@@ -479,15 +527,31 @@ async function buildBuyTransactions({ routeType, params, proxies, wallets, token
     throw new Error(`Unsupported routeType: ${routeType}`);
 }
 /**
- * ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
+ * ✅ 修复：明确分配 nonces，避免隐式状态依赖
  */
 async function allocateProfitAwareNonces(wallets, extractProfit, maxIndex, totalProfit, nonceManager) {
-    // ✅ 批量获取所有钱包的初始 nonce（单次网络往返）
-    const nonces = await nonceManager.getNextNoncesForWallets(wallets);
-    // 如果需要利润转账，maxIndex 钱包需要额外一个 nonce
-    if (extractProfit && totalProfit > 0n && maxIndex >= 0 && maxIndex < wallets.length) {
-        // 预留一个 nonce 给利润交易（从缓存获取，不触发 RPC）
-        await nonceManager.getNextNonce(wallets[maxIndex]);
+    const needProfitTx = extractProfit && totalProfit > 0n && maxIndex >= 0 && maxIndex < wallets.length;
+    if (!needProfitTx) {
+        // 不需要利润交易，所有钱包各 1 个 nonce
+        return await nonceManager.getNextNoncesForWallets(wallets);
+    }
+    // 需要利润交易：maxIndex 钱包需要 2 个连续 nonce
+    const maxIndexNonces = await nonceManager.getNextNonceBatch(wallets[maxIndex], 2);
+    // 其他钱包各需要 1 个 nonce
+    const otherWallets = wallets.filter((_, i) => i !== maxIndex);
+    const otherNonces = otherWallets.length > 0
+        ? await nonceManager.getNextNoncesForWallets(otherWallets)
+        : [];
+    // 组装最终的 nonces 数组（保持原顺序）
+    const nonces = [];
+    let otherIdx = 0;
+    for (let i = 0; i < wallets.length; i++) {
+        if (i === maxIndex) {
+            nonces.push(maxIndexNonces[0]); // 买入交易用第一个 nonce
+        }
+        else {
+            nonces.push(otherNonces[otherIdx++]);
+        }
     }
     return nonces;
 }
@@ -641,36 +705,4 @@ async function buildSellTransactions({ routeType, params, proxies, wallets, toke
     }
     throw new Error(`Unsupported routeType: ${routeType}`);
 }
-async function appendSellProfitTransfer({ extractProfit, quotedOutputs, wallets, nonceManager, signedTxs, gasPrice, chainId, config }) {
-    if (!extractProfit || quotedOutputs.length === 0) {
-        return;
-    }
-    let totalProfit = 0n;
-    let maxRevenueIndex = -1;
-    let maxRevenue = 0n;
-    for (let i = 0; i < wallets.length; i++) {
-        const quoted = quotedOutputs[i];
-        if (quoted > 0n) {
-            const { profit } = calculateProfit(quoted, config);
-            totalProfit += profit;
-            if (quoted > maxRevenue) {
-                maxRevenue = quoted;
-                maxRevenueIndex = i;
-            }
-        }
-    }
-    if (totalProfit === 0n || maxRevenueIndex < 0) {
-        return;
-    }
-    const profitNonce = await nonceManager.getNextNonce(wallets[maxRevenueIndex]);
-    const profitTx = await wallets[maxRevenueIndex].signTransaction({
-        to: getProfitRecipient(),
-        value: totalProfit,
-        nonce: profitNonce,
-        gasPrice,
-        gasLimit: 21000n,
-        chainId,
-        type: getTxType(config)
-    });
-    signedTxs.push(profitTx);
-}
+// ✅ appendSellProfitTransfer 已内联到 pancakeProxyBatchSellMerkle 中，避免 nonce 竞争问题

package/dist/flap/portal-bundle-merkle/swap-buy-first.js

@@ -147,8 +147,8 @@ export async function flapBundleBuyFirstMerkle(params) {
     });
     const portalBuyer = new Contract(chainContext.portalAddress, PORTAL_ABI, buyer);
     const portalSeller = new Contract(chainContext.portalAddress, PORTAL_ABI, seller);
-    // ✅ 优化：第三批并行 - buyUnsigned、sellUnsigned、approvalTx、estimatedSellFunds、noncePlan
-    const [buyUnsigned, sellUnsigned, approvalTx, estimatedSellFunds, noncePlan] = await Promise.all([
+    // ✅ 第三批并行 - buyUnsigned、sellUnsigned、estimatedSellFunds（不含 nonce 相关操作）
+    const [buyUnsigned, sellUnsigned, estimatedSellFunds] = await Promise.all([
         portalBuyer.swapExactInput.populateTransaction({
             inputToken, // ✅ 使用动态输入代币
             outputToken: tokenAddress,
@@ -164,29 +164,30 @@ export async function flapBundleBuyFirstMerkle(params) {
             minOutputAmount: 0,
             permitData: '0x'
         }),
-        buildApprovalTransaction({
-            tokenAddress,
-            provider: chainContext.provider,
-            seller,
-            decimals: sellerInfo.decimals,
-            portalAddress: chainContext.portalAddress,
-            chainId: chainContext.chainId,
-            config,
-            nonceManager,
-            gasPrice,
-            txType
-        }),
-        estimateSellFunds(portalSeller, tokenAddress, sellAmountWei, outputToken),
-        // 预先规划 nonces（假设可能需要利润转账）
-        planNonces({
-            buyer,
-            seller,
-            approvalExists: true, // 保守估计，假设需要授权
-            extractProfit: true, // 保守估计，假设需要利润转账
-            sameAddress,
-            nonceManager
-        })
+        estimateSellFunds(portalSeller, tokenAddress, sellAmountWei, outputToken)
     ]);
+    // ✅ 修复：先构建授权交易（会消耗 nonce），再规划其他 nonce
+    const approvalTx = await buildApprovalTransaction({
+        tokenAddress,
+        provider: chainContext.provider,
+        seller,
+        decimals: sellerInfo.decimals,
+        portalAddress: chainContext.portalAddress,
+        chainId: chainContext.chainId,
+        config,
+        nonceManager,
+        gasPrice,
+        txType
+    });
+    // ✅ 修复：根据实际的授权情况规划 nonce
+    const noncePlan = await planNonces({
+        buyer,
+        seller,
+        approvalExists: approvalTx !== null, // ✅ 使用实际值
+        extractProfit: true,
+        sameAddress,
+        nonceManager
+    });
     // ✅ 修复：基于卖出收益估算利润
     const profitBase = estimatedSellFunds > 0n ? estimatedSellFunds : buyerFundsWei;
     const tokenProfitAmount = calculateProfitAmount(profitBase);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.3.39",
+  "version": "1.3.40",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",