four-flap-meme-sdk 1.3.54 → 1.3.55

package/dist/dex/direct-router.d.ts

@@ -22,7 +22,7 @@ export declare const DIRECT_ROUTERS: {
         readonly WMON: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a";
     };
     readonly XLAYER: {
-        readonly POTATOSWAP_V2: "0xB45D0149249488333E3F3f9F359807F4b810C1FC";
+        readonly POTATOSWAP_V2: "0x881fb2f98c13d521009464e7d1cbf16e1b394e8e";
         readonly POTATOSWAP_V3: "0xB45D0149249488333E3F3f9F359807F4b810C1FC";
         readonly V3_ROUTER: "0xBB069e9465BcabC4F488d21e793BDEf0F2d41D41";
         readonly V3_FACTORY: "0xa1415fAe79c4B196d087F02b8aD5a622B8A827E5";

package/dist/dex/direct-router.js

@@ -33,12 +33,13 @@ export const DIRECT_ROUTERS = {
         // Wrapped Native
         WMON: '0x3bd359c1119da7da1d913d1c4d2b7c461115433a',
     },
-    // ✅ 新增 XLayer (PotatoSwap)
+    // ✅ XLayer (PotatoSwap)
     XLAYER: {
-        // PotatoSwap - SwapRouter02 同时支持 V2 和 V3
-        POTATOSWAP_V2: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (V2+V3)
-        POTATOSWAP_V3: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (V2+V3)
-        // V3 专用 Router（可选）
+        // PotatoSwap V2 Router - 标准 Uniswap V2 风格，支持 swapExactTokensForETHSupportingFeeOnTransferTokens
+        POTATOSWAP_V2: '0x881fb2f98c13d521009464e7d1cbf16e1b394e8e', // ✅ 真正的 V2 Router
+        // PotatoSwap SwapRouter02 - V3 风格，支持 multicall
+        POTATOSWAP_V3: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (V3 风格)
+        // V3 专用 Router
         V3_ROUTER: '0xBB069e9465BcabC4F488d21e793BDEf0F2d41D41',
         V3_FACTORY: '0xa1415fAe79c4B196d087F02b8aD5a622B8A827E5',
         // Wrapped Native
@@ -82,14 +83,14 @@ const V2_ROUTER_ABI = [
 /**
  * SwapRouter02 的 V2 方法 ABI (PotatoSwap)
  *
- * 重要：SwapRouter02 的 V2 方法只有：
+ * 重要：根据实际 ABI，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
+ * 必须手动处理 ETH/WETH 转换：
+ * - 买入(ETH→Token): wrapETH + swapExactTokensForTokens，通过 multicall 组合
+ * - 卖出(Token→ETH): swapExactTokensForTokens(to=ADDRESS_THIS) + unwrapWETH9，通过 multicall 组合
  */
 const SWAP_ROUTER02_V2_ABI = [
     // V2 交换方法（只有 token-to-token）
@@ -97,15 +98,15 @@ const SWAP_ROUTER02_V2_ABI = [
     '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(bytes32 previousBlockhash, bytes[] calldata data) external payable returns (bytes[] memory results)',
     'function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)',
     // 辅助方法 - 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 中的代币发送给用户
     'function sweepToken(address token, uint256 amountMinimum, address recipient) external payable',
     'function sweepToken(address token, uint256 amountMinimum) external payable',
 ];
@@ -269,20 +270,26 @@ async function buildProfitTransaction(wallet, profitAmountWei, nonce, gasPrice,
 // V2 直接交易
 // ============================================================================
 /**
- * 判断是否是 SwapRouter02 (PotatoSwap, PancakeSwap V3 等)
- * SwapRouter02 的 V2 方法签名不同，需要特殊处理
+ * 判断是否是 SwapRouter02 (仅 XLayer PotatoSwap)
+ *
+ * 只有 XLayer PotatoSwap 使用 SwapRouter02 进行 V2 交易
+ * BSC/Monad 的 V2 交易使用传统的 V2 Router（带 deadline 参数）
+ *
+ * SwapRouter02 的 V2 方法签名不同：
+ * - swapExactETHForTokens(amountOutMin, path[], to) - 没有 deadline
+ * - swapExactTokensForETH(amountIn, amountOutMin, path[], to) - 没有 deadline
  */
 function isSwapRouter02(chain, routerAddress) {
     const chainUpper = chain.toUpperCase();
     const addrLower = routerAddress.toLowerCase();
-    // XLayer PotatoSwap SwapRouter02
-    if (chainUpper === 'XLAYER' && addrLower === DIRECT_ROUTERS.XLAYER.POTATOSWAP_V2.toLowerCase()) {
-        return true;
-    }
-    // BSC PancakeSwap V3 SwapRouter02
-    if (chainUpper === 'BSC' && addrLower === DIRECT_ROUTERS.BSC.PANCAKESWAP_V3.toLowerCase()) {
+    // ✅ 只有 XLayer PotatoSwap SwapRouter02 (V3 风格) 走这个逻辑
+    // 注意：POTATOSWAP_V2 现在是真正的 V2 Router，不需要 SwapRouter02 逻辑
+    if (chainUpper === 'XLAYER' && addrLower === DIRECT_ROUTERS.XLAYER.POTATOSWAP_V3.toLowerCase()) {
         return true;
     }
+    // ❌ XLayer POTATOSWAP_V2 (0x881fb...) 是标准 V2 Router，不走 SwapRouter02 逻辑
+    // ❌ BSC V2 交易使用传统 PancakeSwap V2 Router，不走 SwapRouter02 逻辑
+    // ❌ Monad V2 交易使用传统 V2 Router，不走 SwapRouter02 逻辑
     return false;
 }
 /**
@@ -326,42 +333,39 @@ export async function directV2BatchBuy(params) {
         let txData;
         let txValue;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH wrap
-            // 文档：没有 swapExactETHForTokens / swapExactTokensForETH
-            const multicallData = [];
+            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
+            // ABI 中没有 swapExactETHForTokens，只有 swapExactTokensForTokens
             if (useNative) {
-                // ETH -> 代币：
-                // 1. wrapETH(msg.value) - 将 ETH 转为 WETH
-                // 2. swapExactTokensForTokens(WETH -> Token)
-                const wrapData = routerIface.encodeFunctionData('wrapETH', [amountWei]);
-                multicallData.push(wrapData);
+                // ETH -> 代币：直接用 swapExactTokensForTokens（参考之前成功的交易）
+                // 之前成功的交易只用了一个 swapExactTokensForTokens，没有 wrapETH
+                // SwapRouter02 会自动处理 msg.value 的 ETH
                 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);
+                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
+                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
+                    deadline,
+                    [swapData],
+                ]);
+                txValue = amountWei;
             }
             else {
-                // 代币 -> 代币：直接 swapExactTokensForTokens
+                // 代币 -> 代币：也用 multicall 包装
                 const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
                     amountWei,
                     0n, // amountOutMin
                     path,
                     wallet.address, // to
                 ]);
-                multicallData.push(swapData);
+                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
+                    deadline,
+                    [swapData],
+                ]);
+                txValue = 0n;
             }
-            // 使用 multicall 包装，传递 deadline
-            txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                deadline,
-                multicallData,
-            ]);
-            txValue = useNative ? amountWei : 0n;
         }
         else if (useNative) {
             // 传统 V2 Router: 原生币 → Token
@@ -417,15 +421,28 @@ export async function directV2BatchBuy(params) {
  * V2 批量卖出（直接调用 Router）
  */
 export async function directV2BatchSell(params) {
-    const { chain, privateKeys, sellPercentages, sellAmounts, tokenAddress, tokenDecimals = 18, routerAddress, quoteToken, config, } = params;
+    const { chain, privateKeys, sellPercentages, sellAmounts, tokenAddress, tokenDecimals: inputDecimals, routerAddress, quoteToken, config, } = params;
     const chainId = config.chainId || CHAIN_IDS[chain.toUpperCase()] || 56;
     const provider = new JsonRpcProvider(config.rpcUrl, { chainId, name: chain });
     const useNativeOutput = isNativeToken(quoteToken);
     const wrappedNative = getWrappedNative(chain);
     // 创建钱包
     const wallets = privateKeys.map(pk => new Wallet(pk, provider));
-    // 获取代币余额
+    // 获取代币合约
     const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider);
+    // ✅ 自动获取代币精度（如果未提供）
+    let tokenDecimals = inputDecimals;
+    if (tokenDecimals === undefined) {
+        try {
+            tokenDecimals = Number(await tokenContract.decimals());
+            console.log(`📊 自动获取代币精度: ${tokenDecimals}`);
+        }
+        catch {
+            tokenDecimals = 18; // 默认 18
+            console.log(`⚠️ 无法获取代币精度，使用默认值: ${tokenDecimals}`);
+        }
+    }
+    // 获取代币余额
     const balances = await Promise.all(wallets.map(w => tokenContract.balanceOf(w.address)));
     // 计算卖出数量
     const sellAmountsWei = [];
@@ -488,46 +505,54 @@ export async function directV2BatchSell(params) {
         // 卖出交易
         let txData;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH unwrap
-            const router02Iface = new ethers.Interface(SWAP_ROUTER02_V2_ABI);
-            const multicallData = [];
-            // SwapRouter02 特殊地址约定：
-            // address(1) = ADDRESS_THIS = Router 合约自己
-            // address(2) = MSG_SENDER = 调用者
-            const ADDRESS_THIS = '0x0000000000000000000000000000000000000001'; // Router 自己
+            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
+            // 
+            // 重要：SwapRouter02 的 V2 swapExactTokensForTokens 直接把代币发给 to 地址
+            // 如果需要 ETH，把 WETH 发给 Router，然后调用 unwrapWETH9
+            // 
+            // 根据合约源码，address(2) = ADDRESS_THIS = Router 合约自己
+            const ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
             if (useNativeOutput) {
                 // 代币 -> ETH：
-                // 1. swapExactTokensForTokens(token -> WETH, to = ADDRESS_THIS)
-                // 2. unwrapWETH9(WETH -> ETH, to = 用户)
-                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
+                // 方案1：swapExactTokensForTokens(to=Router) + unwrapWETH9
+                // 方案2：直接发 WETH 给用户（用户需要手动 unwrap）
+                // 
+                // 使用方案1：发送到 Router 地址（真实地址，不是 address(2)）
+                const routerRealAddress = routerAddress; // SwapRouter02 的真实地址
+                const multicallData = [];
+                // 1. swapExactTokensForTokens - 从用户转代币，换成 WETH 发到 Router 真实地址
+                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
                     sellAmount,
                     0n, // amountOutMin
                     path, // path: [token, ..., WETH]
-                    ADDRESS_THIS, // to = Router 自己，WETH 留在 Router 中
+                    ADDRESS_THIS, // to = address(2)，让 Router 接收 WETH
                 ]);
                 multicallData.push(swapData);
-                // unwrap WETH -> ETH 发送给用户
-                const unwrapData = router02Iface.encodeFunctionData('unwrapWETH9(uint256,address)', [
-                    0n, // amountMinimum
+                // 2. unwrapWETH9 - 将 Router 中的 WETH 解包为 ETH 发送给用户
+                const unwrapData = routerIface.encodeFunctionData('unwrapWETH9(uint256,address)', [
+                    0n, // amountMinimum = 0，接受任意数量
                     wallet.address, // recipient = 用户
                 ]);
                 multicallData.push(unwrapData);
+                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
+                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
+                    deadline,
+                    multicallData,
+                ]);
             }
             else {
                 // 代币 -> 代币：直接 swapExactTokensForTokens
-                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
+                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
                     sellAmount,
                     0n, // amountOutMin
                     path,
-                    wallet.address, // to
+                    wallet.address, // to = 用户
+                ]);
+                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
+                    deadline,
+                    [swapData],
                 ]);
-                multicallData.push(swapData);
             }
-            // 使用 multicall 包装，传递 deadline
-            txData = router02Iface.encodeFunctionData('multicall(uint256,bytes[])', [
-                deadline,
-                multicallData,
-            ]);
         }
         else if (useNativeOutput) {
             txData = routerIface.encodeFunctionData('swapExactTokensForETHSupportingFeeOnTransferTokens', [

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

@@ -300,15 +300,9 @@ async function calculateBuyerFunds({ buyer, buyerFunds, buyerFundsPercentage, re
         }
     }
     else {
-        // ERC20 购买：检查代币余额
         if (buyerBalance < buyerFundsWei) {
             throw new Error(`买方代币余额不足: 需要 ${ethers.formatUnits(buyerFundsWei, quoteTokenDecimals)}，实际 ${ethers.formatUnits(buyerBalance, quoteTokenDecimals)}`);
         }
-        // ✅ ERC20 购买时，还需要检查买方是否有足够 BNB 支付 Gas
-        const buyerBnbBalance = await buyer.provider.getBalance(buyer.address);
-        if (buyerBnbBalance < reserveGas) {
-            throw new Error(`买方 BNB 余额不足 (用于支付 Gas): 需要 ${ethers.formatEther(reserveGas)} ${nativeToken}，实际 ${ethers.formatEther(buyerBnbBalance)} ${nativeToken}`);
-        }
     }
     return { buyerFundsWei, buyerBalance };
 }

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

@@ -194,9 +194,7 @@ export async function flapBundleSwapMerkle(params) {
             portalGasCost: finalGasLimit * gasPrice,
             provider: chainContext.provider,
             chainContext,
-            seller,
-            useNativeToken, // ✅ 传递是否使用原生代币
-            quoteTokenDecimals // ✅ 传递代币精度
+            seller
         })
     ]);
     // 构建交易请求
@@ -366,21 +364,13 @@ async function calculateBuyerNeed({ buyer, quotedNative, reserveGasEth, slippage
         : (useNativeToken ? buyerBalance - reserveGas : buyerBalance);
     return { reserveGas, buyerBalance, buyerNeedTotal, maxBuyerValue };
 }
-async function validateBalances({ buyerNeed, buyerAddress, portalGasCost, provider, chainContext, seller, useNativeToken, quoteTokenDecimals = 18 }) {
+async function validateBalances({ buyerNeed, buyerAddress, portalGasCost, provider, chainContext, seller }) {
+    const buyerBalance = buyerNeed.buyerBalance;
     const sellerBalance = await provider.getBalance(seller.address);
-    // ✅ 修复：买方余额已在 calculateBuyerNeed 中检查过
-    // 这里只需要检查：
-    // 1. 使用原生代币时：buyerNeed.buyerBalance 已包含购买金额 + Gas
-    // 2. 使用 ERC20 时：需要额外检查买方是否有足够 BNB 支付 Gas
-    if (!useNativeToken) {
-        // ERC20 购买时，买方仍需要 BNB 支付 Gas
-        const buyerBnbBalance = await provider.getBalance(buyerAddress);
-        const buyerGasCost = portalGasCost; // 买方交易的 Gas 费用
-        if (buyerBnbBalance < buyerGasCost) {
-            throw new Error(`买方 BNB 余额不足 (用于支付 Gas):\n` +
-                `  - 需要: ${ethers.formatEther(buyerGasCost)} ${chainContext.nativeToken}\n` +
-                `  - 实际: ${ethers.formatEther(buyerBnbBalance)} ${chainContext.nativeToken}`);
-        }
+    if (buyerBalance < buyerNeed.buyerNeedTotal) {
+        throw new Error(`买方余额不足:\n` +
+            `  - 需要: ${ethers.formatEther(buyerNeed.buyerNeedTotal)} ${chainContext.nativeToken}\n` +
+            `  - 实际: ${ethers.formatEther(buyerBalance)} ${chainContext.nativeToken}`);
     }
     if (sellerBalance < portalGasCost) {
         throw new Error(`卖方余额不足: 需要 ${ethers.formatEther(portalGasCost)} ${chainContext.nativeToken} (Gas)，实际 ${ethers.formatEther(sellerBalance)} ${chainContext.nativeToken}`);

package/dist/utils/constants.d.ts

@@ -53,7 +53,8 @@ export declare const ADDRESSES: {
         readonly FlapPortal: "0xb30D8c4216E1f21F27444D2FfAee3ad577808678";
         readonly WOKB: "0xe538905cf8410324e03a5a23c1c177a474d59b2b";
         readonly Multicall3: "0xca11bde05977b3631167028862be2a173976ca11";
-        readonly PotatoSwapV2Router: "0xB45D0149249488333E3F3f9F359807F4b810C1FC";
+        readonly PotatoSwapV2Router: "0x881fb2f98c13d521009464e7d1cbf16e1b394e8e";
+        readonly PotatoSwapSwapRouter02: "0xB45D0149249488333E3F3f9F359807F4b810C1FC";
         readonly PotatoSwapV3Router: "0xBB069e9465BcabC4F488d21e793BDEf0F2d41D41";
         readonly PotatoSwapV3Factory: "0xa1415fAe79c4B196d087F02b8aD5a622B8A827E5";
         readonly USDT: "0x1e4a5963abfd975d8c9021ce480b42188849d41d";

package/dist/utils/constants.js

@@ -52,7 +52,8 @@ export const ADDRESSES = {
         // Multicall3 合约
         Multicall3: '0xca11bde05977b3631167028862be2a173976ca11',
         // PotatoSwap DEX 合约
-        PotatoSwapV2Router: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (支持 V2+V3)
+        PotatoSwapV2Router: '0x881fb2f98c13d521009464e7d1cbf16e1b394e8e', // ✅ V2 Router (标准 Uniswap V2 风格)
+        PotatoSwapSwapRouter02: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (V3 风格)
         PotatoSwapV3Router: '0xBB069e9465BcabC4F488d21e793BDEf0F2d41D41', // V3 Router
         PotatoSwapV3Factory: '0xa1415fAe79c4B196d087F02b8aD5a622B8A827E5', // V3 Factory
         // 稳定币

package/dist/utils/lp-inspect.js

@@ -60,10 +60,9 @@ const CHAIN_DEX_CONFIGS = {
         dexes: {
             POTATOSWAP: {
                 name: 'PotatoSwap',
-                // SwapRouter02 同时支持 V2 和 V3
-                v2Factory: '0x630DB8E822805c82Ca40a54daE02dd5aC31f7fcF', // ✅ V2 Factory (从 SwapRouter02.factoryV2() 获取)
-                v2Router: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02
-                v3Router: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02
+                v2Factory: '0x630DB8E822805c82Ca40a54daE02dd5aC31f7fcF', // V2 Factory
+                v2Router: '0x881fb2f98c13d521009464e7d1cbf16e1b394e8e', // ✅ V2 Router (标准 Uniswap V2 风格)
+                v3Router: '0xB45D0149249488333E3F3f9F359807F4b810C1FC', // SwapRouter02 (V3 风格)
                 v3Factory: '0xa1415fAe79c4B196d087F02b8aD5a622B8A827E5', // V3 Factory
                 quoterV2: '0x5A6f3723346aF54a4D0693bfC1718D64d4915C3e', // QuoterV2
                 enabled: true,

package/package.json

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

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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,146 +0,0 @@
-/**
- * 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;
-    }
-}