four-flap-meme-sdk 1.3.43 → 1.3.45

package/dist/dex/direct-router.js

@@ -80,23 +80,29 @@ const V2_ROUTER_ABI = [
     'function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)',
 ];
 /**
- * SwapRouter02 的 V2 方法 ABI (PotatoSwap, PancakeSwap V3 Router)
- * SwapRouter02 同时支持 V2 和 V3，V2 方法通过 multicall 调用
+ * SwapRouter02 的 V2 方法 ABI (PotatoSwap)
  *
- * 注意：SwapRouter02 的 V2SwapRouter 方法签名：
- * - swapExactTokensForTokens(amountIn, amountOutMin, path[], to) - 不含 deadline
- * - 卖出时需要先 approve，Router 会自动 pull 代币
+ * 重要：SwapRouter02 的 V2 方法只有：
+ * - swapExactTokensForTokens(amountIn, amountOutMin, path[], to)
+ * - swapTokensForExactTokens(amountOut, amountInMax, path[], to)
+ *
+ * 没有 swapExactETHForTokens / swapExactTokensForETH！
+ * 需要手动处理 ETH/WETH 转换：
+ * - 买入(ETH->Token): wrapETH + swapExactTokensForTokens
+ * - 卖出(Token->ETH): swapExactTokensForTokens(to=ADDRESS_THIS) + unwrapWETH9
  */
 const SWAP_ROUTER02_V2_ABI = [
-    // V2 交换方法 (SwapRouter02 内置)
+    // V2 交换方法（只有 token-to-token）
     'function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to) external payable returns (uint256 amountOut)',
+    'function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to) external payable returns (uint256 amountIn)',
     // Multicall - 多种重载
     'function multicall(uint256 deadline, bytes[] calldata data) external payable returns (bytes[] memory results)',
     'function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)',
-    // 辅助方法
-    'function refundETH() external payable',
+    // 辅助方法 - ETH/WETH 转换
+    'function wrapETH(uint256 value) external payable',
     'function unwrapWETH9(uint256 amountMinimum, address recipient) external payable',
     'function unwrapWETH9(uint256 amountMinimum) external payable',
+    'function refundETH() external payable',
     // pull 方法 - 从用户拉取代币到 Router
     'function pull(address token, uint256 value) external payable',
     // sweepToken - 将 Router 中的代币发送给用户
@@ -177,8 +183,11 @@ const V3_ROUTER_LEGACY_ABI = [
  * - Uniswap V3: 0xd6145b2d3f379919e8cdeda7b97e37c4b2ca9c40
  * - PancakeSwap V3: 0x1b81D678ffb9C0263b24A97847620C99d213eB14
  *
+ * XLayer:
+ * - V3 Router (0xBB069e9465BcabC4F488d21e793BDEf0F2d41D41) - 旧版（exactInputSingle 包含 deadline）
+ * - SwapRouter02 (0xB45D0149249488333E3F3f9F359807F4b810C1FC) - 新版（V2+V3 混合）
+ *
  * BSC PancakeSwap V3 使用新版 SwapRouter02
- * XLayer PotatoSwap SwapRouter02 使用新版
  */
 function isLegacySwapRouter(chain, routerAddress) {
     const chainUpper = chain.toUpperCase();
@@ -192,8 +201,15 @@ function isLegacySwapRouter(chain, routerAddress) {
             return true;
         }
     }
-    // ✅ XLayer PotatoSwap 使用新版 SwapRouter02
-    // BSC PancakeSwap V3 使用新版 SwapRouter02
+    // ✅ XLayer V3 专用 Router 是旧版（exactInputSingle 包含 deadline）
+    if (chainUpper === 'XLAYER') {
+        if (routerLower === DIRECT_ROUTERS.XLAYER.V3_ROUTER.toLowerCase()) {
+            return true; // V3 Router 是旧版
+        }
+        // SwapRouter02 是新版
+        return false;
+    }
+    // ✅ BSC PancakeSwap V3 使用新版 SwapRouter02
     return false;
 }
 /** ERC20 ABI */
@@ -310,18 +326,40 @@ export async function directV2BatchBuy(params) {
         let txData;
         let txValue;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02 V2 方法：使用 multicall 包装
-            // SwapRouter02.swapExactTokensForTokens 不含 deadline，需要通过 multicall 传递
-            const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                amountWei,
-                0n, // amountOutMin
-                path,
-                wallet.address,
-            ]);
+            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH wrap
+            // 文档：没有 swapExactETHForTokens / swapExactTokensForETH
+            const multicallData = [];
+            if (useNative) {
+                // ETH -> 代币：
+                // 1. wrapETH(msg.value) - 将 ETH 转为 WETH
+                // 2. swapExactTokensForTokens(WETH -> Token)
+                const wrapData = routerIface.encodeFunctionData('wrapETH', [amountWei]);
+                multicallData.push(wrapData);
+                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
+                    amountWei,
+                    0n, // amountOutMin
+                    path, // path: [WETH, ..., tokenOut]
+                    wallet.address, // to
+                ]);
+                multicallData.push(swapData);
+                // refundETH - 退回多余的 ETH（如果有）
+                const refundData = routerIface.encodeFunctionData('refundETH', []);
+                multicallData.push(refundData);
+            }
+            else {
+                // 代币 -> 代币：直接 swapExactTokensForTokens
+                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
+                    amountWei,
+                    0n, // amountOutMin
+                    path,
+                    wallet.address, // to
+                ]);
+                multicallData.push(swapData);
+            }
             // 使用 multicall 包装，传递 deadline
-            txData = routerIface.encodeFunctionData('multicall', [
+            txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
                 deadline,
-                [swapData],
+                multicallData,
             ]);
             txValue = useNative ? amountWei : 0n;
         }
@@ -450,26 +488,41 @@ export async function directV2BatchSell(params) {
         // 卖出交易
         let txData;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02: 卖出代币换原生币
-            // 流程：swapExactTokensForTokens (token -> WETH) + unwrapWETH9 (WETH -> ETH)
+            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH unwrap
             const router02Iface = new ethers.Interface(SWAP_ROUTER02_V2_ABI);
-            // 1. swap: token -> WETH (recipient 设为 Router 地址 address(2) 表示 Router 自己)
-            const ADDRESS_THIS = '0x0000000000000000000000000000000000000002'; // SwapRouter02 特殊地址，表示 Router 自己
-            const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
-                sellAmount,
-                0n, // amountOutMin
-                path,
-                useNativeOutput ? ADDRESS_THIS : wallet.address, // 如果输出是原生币，先发到 Router
-            ]);
-            const multicallData = [swapData];
-            // 2. 如果输出是原生币，需要 unwrapWETH9
+            const multicallData = [];
+            // SwapRouter02 特殊地址约定：
+            // address(1) = ADDRESS_THIS = Router 合约自己
+            // address(2) = MSG_SENDER = 调用者
+            const ADDRESS_THIS = '0x0000000000000000000000000000000000000001'; // Router 自己
             if (useNativeOutput) {
+                // 代币 -> ETH：
+                // 1. swapExactTokensForTokens(token -> WETH, to = ADDRESS_THIS)
+                // 2. unwrapWETH9(WETH -> ETH, to = 用户)
+                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
+                    sellAmount,
+                    0n, // amountOutMin
+                    path, // path: [token, ..., WETH]
+                    ADDRESS_THIS, // to = Router 自己，WETH 留在 Router 中
+                ]);
+                multicallData.push(swapData);
+                // unwrap WETH -> ETH 发送给用户
                 const unwrapData = router02Iface.encodeFunctionData('unwrapWETH9(uint256,address)', [
                     0n, // amountMinimum
-                    wallet.address, // recipient
+                    wallet.address, // recipient = 用户
                 ]);
                 multicallData.push(unwrapData);
             }
+            else {
+                // 代币 -> 代币：直接 swapExactTokensForTokens
+                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
+                    sellAmount,
+                    0n, // amountOutMin
+                    path,
+                    wallet.address, // to
+                ]);
+                multicallData.push(swapData);
+            }
             // 使用 multicall 包装，传递 deadline
             txData = router02Iface.encodeFunctionData('multicall(uint256,bytes[])', [
                 deadline,

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

@@ -297,17 +297,62 @@ export async function batchSellWithBundleMerkle(params) {
     const useNativeOutput = outputToken === ZERO_ADDRESS;
     // ✅ 优化：如果前端传入了 nonces，直接使用（跳过 RPC 调用）
     const presetNonces = config.nonces;
-    // ✅ 并行执行 gasPrice、quoteSellOutputs（Multicall3）和 nonces
-    const [gasPrice, quotedOutputs, nonces] = await Promise.all([
+    const extractProfit = shouldExtractProfit(config);
+    // ✅ 并行执行 gasPrice 和 quoteSellOutputs（Multicall3）
+    const [gasPrice, quotedOutputs] = await Promise.all([
         resolveGasPrice(provider, config),
-        quoteSellOutputsWithQuote(readOnlyPortal, tokenAddress, amountsWei, outputToken),
-        presetNonces && presetNonces.length === wallets.length
-            ? Promise.resolve(presetNonces) // ✅ 使用前端传入的 nonces
-            : nonceManager.getNextNoncesForWallets(wallets)
+        quoteSellOutputsWithQuote(readOnlyPortal, tokenAddress, amountsWei, outputToken)
     ]);
-    if (presetNonces) {
+    // ✅ 计算利润和 maxRevenueIndex（用于 nonce 分配）
+    let totalTokenProfit = 0n;
+    let maxRevenueIndex = -1;
+    let maxRevenue = 0n;
+    if (extractProfit && quotedOutputs.length > 0) {
+        for (let i = 0; i < wallets.length; i++) {
+            const quoted = quotedOutputs[i];
+            if (quoted > 0n) {
+                const { profit } = calculateProfit(quoted, config);
+                totalTokenProfit += profit;
+                if (quoted > maxRevenue) {
+                    maxRevenue = quoted;
+                    maxRevenueIndex = i;
+                }
+            }
+        }
+    }
+    // ✅ 修复：根据是否需要利润交易，统一分配 nonces
+    const needProfitTx = extractProfit && totalTokenProfit > 0n && maxRevenueIndex >= 0;
+    let nonces;
+    let profitNonce;
+    if (presetNonces && presetNonces.length === wallets.length) {
+        nonces = presetNonces;
         console.log('🚀 SDK 使用前端传入的 nonces:', presetNonces);
     }
+    else if (needProfitTx) {
+        // maxRevenueIndex 钱包需要 2 个连续 nonce（卖出 + 利润）
+        const maxRevenueNonces = await nonceManager.getNextNonceBatch(wallets[maxRevenueIndex], 2);
+        // 其他钱包各需要 1 个 nonce
+        const otherWallets = wallets.filter((_, i) => i !== maxRevenueIndex);
+        const otherNonces = otherWallets.length > 0
+            ? await nonceManager.getNextNoncesForWallets(otherWallets)
+            : [];
+        // 组装最终的 nonces 数组（保持原顺序）
+        nonces = [];
+        let otherIdx = 0;
+        for (let i = 0; i < wallets.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(wallets);
+    }
     const minOuts = resolveMinOutputs(minOutputAmounts, wallets.length, quotedOutputs);
     // ✅ 优化：构建未签名交易（这里是本地操作，但仍然并行执行以提高效率）
     const unsignedList = await Promise.all(portals.map((portal, i) => portal.swapExactInput.populateTransaction({
@@ -330,19 +375,31 @@ export async function batchSellWithBundleMerkle(params) {
         value: 0n // ✅ 卖出交易不发送原生代币
     })));
     signedTxs.push(...signedList);
-    await appendSellProfitTransaction({
-        extractProfit: shouldExtractProfit(config),
-        quotedOutputs,
-        wallets,
-        nonceManager,
-        signedTxs,
-        chainId,
-        gasPrice,
-        config,
-        outputToken, // ✅ 传递 outputToken
-        useNativeOutput, // ✅ 传递是否原生代币输出
-        provider // ✅ 传递 provider 用于报价
-    });
+    // ✅ 修复：使用预先分配的 profitNonce 添加利润交易
+    if (needProfitTx && profitNonce !== undefined) {
+        // ERC20 输出时：获取代币利润等值的原生代币（BNB）报价
+        let nativeProfitAmount = totalTokenProfit;
+        if (!useNativeOutput && outputToken) {
+            nativeProfitAmount = await getTokenToNativeQuote(provider, outputToken, totalTokenProfit, chainId);
+            console.log('🔍 SDK ERC20 卖出利润转换: ', ethers.formatEther(totalTokenProfit), ' Token -> ', ethers.formatEther(nativeProfitAmount), ' BNB');
+            // 如果报价失败（返回 0），跳过利润提取
+            if (nativeProfitAmount === 0n) {
+                console.log('🔍 SDK ERC20 卖出利润转换失败，跳过利润提取');
+            }
+        }
+        if (nativeProfitAmount > 0n) {
+            const profitTx = await wallets[maxRevenueIndex].signTransaction({
+                to: getProfitRecipient(),
+                value: nativeProfitAmount,
+                nonce: profitNonce,
+                gasPrice,
+                gasLimit: 23000n,
+                chainId,
+                type: getTxType(config)
+            });
+            signedTxs.push(profitTx);
+        }
+    }
     nonceManager.clearTemp();
     return {
         signedTransactions: signedTxs
@@ -434,19 +491,33 @@ function buildGasLimitList(length, config) {
     return new Array(length).fill(gasLimit);
 }
 /**
- * ✅ 优化：批量获取所有钱包的 nonce（单次批量 RPC）
- * 使用 getNextNoncesForWallets 批量获取，比 Promise.all 更高效
+ * ✅ 修复：明确分配 nonces，避免隐式状态依赖
  */
 async function allocateBuyerNonces(buyers, extractProfit, maxIndex, totalProfit, nonceManager) {
-    // ✅ 批量获取所有钱包的初始 nonce（内部会合并 RPC 请求）
-    const initialNonces = await nonceManager.getNextNoncesForWallets(buyers);
-    // 如果需要提取利润，maxIndex 钱包需要额外一个 nonce（用于利润转账）
-    // NonceManager 内部已经缓存了，这里只是递增缓存
-    if (extractProfit && totalProfit > 0n && maxIndex >= 0 && maxIndex < buyers.length) {
-        // 再获取一个 nonce 给利润交易（从缓存中获取，不会触发 RPC）
-        await nonceManager.getNextNonce(buyers[maxIndex]);
+    const needProfitTx = extractProfit && totalProfit > 0n && maxIndex >= 0 && maxIndex < buyers.length;
+    if (!needProfitTx) {
+        // 不需要利润交易，所有钱包各 1 个 nonce
+        return await nonceManager.getNextNoncesForWallets(buyers);
     }
-    return initialNonces;
+    // 需要利润交易：maxIndex 钱包需要 2 个连续 nonce（买入 + 利润）
+    const maxIndexNonces = await nonceManager.getNextNonceBatch(buyers[maxIndex], 2);
+    // 其他钱包各需要 1 个 nonce
+    const otherBuyers = buyers.filter((_, i) => i !== maxIndex);
+    const otherNonces = otherBuyers.length > 0
+        ? await nonceManager.getNextNoncesForWallets(otherBuyers)
+        : [];
+    // 组装最终的 nonces 数组（保持原顺序）
+    const nonces = [];
+    let otherIdx = 0;
+    for (let i = 0; i < buyers.length; i++) {
+        if (i === maxIndex) {
+            nonces.push(maxIndexNonces[0]); // 买入交易用第一个 nonce
+        }
+        else {
+            nonces.push(otherNonces[otherIdx++]);
+        }
+    }
+    return nonces;
 }
 async function signBuyTransactions({ unsignedBuys, buyers, nonces, gasLimits, gasPrice, chainId, config, fundsList, useNativeToken = true // ✅ 默认使用原生代币
  }) {
@@ -471,7 +542,7 @@ async function appendProfitTransaction({ extractProfit, totalProfit, buyers, max
         value: totalProfit,
         nonce: profitNonce,
         gasPrice,
-        gasLimit: 21000n,
+        gasLimit: 23000n,
         chainId,
         type: getTxType(config)
     });
@@ -562,45 +633,4 @@ function resolveMinOutputs(provided, walletCount, _quotedOutputs) {
     // 原因：大额交易时 5% 滑点可能不够，导致交易失败
     return Array(walletCount).fill(0n);
 }
-async function appendSellProfitTransaction({ extractProfit, quotedOutputs, wallets, nonceManager, signedTxs, chainId, gasPrice, config, outputToken, useNativeOutput = true, provider }) {
-    if (!extractProfit || quotedOutputs.length === 0) {
-        return;
-    }
-    let totalTokenProfit = 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);
-            totalTokenProfit += profit;
-            if (quoted > maxRevenue) {
-                maxRevenue = quoted;
-                maxRevenueIndex = i;
-            }
-        }
-    }
-    if (totalTokenProfit === 0n || maxRevenueIndex < 0) {
-        return;
-    }
-    // ✅ ERC20 输出：获取代币利润等值的原生代币（BNB）报价
-    let nativeProfitAmount = totalTokenProfit; // 原生代币输出时直接使用
-    if (!useNativeOutput && outputToken && provider) {
-        nativeProfitAmount = await getTokenToNativeQuote(provider, outputToken, totalTokenProfit, chainId);
-        // 如果报价失败（返回 0），跳过利润提取
-        if (nativeProfitAmount === 0n) {
-            return;
-        }
-    }
-    const profitNonce = await nonceManager.getNextNonce(wallets[maxRevenueIndex]);
-    const profitTx = await wallets[maxRevenueIndex].signTransaction({
-        to: getProfitRecipient(),
-        value: nativeProfitAmount, // ✅ 转等值原生代币
-        nonce: profitNonce,
-        gasPrice,
-        gasLimit: 21000n,
-        chainId,
-        type: getTxType(config)
-    });
-    signedTxs.push(profitTx);
-}
+// ✅ appendSellProfitTransaction 已内联到 batchSellWithBundleMerkle 中，避免 nonce 竞争问题

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/package.json

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