four-flap-meme-sdk 1.5.98 → 1.6.1

package/dist/utils/holders-maker.d.ts

@@ -7,7 +7,7 @@
  */
 import { type GeneratedWallet } from './wallet.js';
 /** 链类型 */
-export type HoldersMakerChain = 'BSC' | 'MONAD';
+export type HoldersMakerChain = 'BSC' | 'MONAD' | 'XLAYER';
 /** 交易类型 */
 export type TradeType = 'four' | 'flap' | 'v2' | 'v3';
 /** 基础代币类型 */

package/dist/utils/holders-maker.js

@@ -15,13 +15,17 @@ import { V2_ROUTER_ABI, V3_ROUTER02_ABI, ERC20_ABI } from '../abis/common.js';
 const FOUR_TM2_ABI = [
     'function buyTokenAMAP(uint256 origin, address token, address to, uint256 funds, uint256 minAmount) payable'
 ];
-// PancakeSwap Router 地址
+// PancakeSwap Router 地址 (BSC)
 const PANCAKE_V2_ROUTER_ADDRESS = ADDRESSES.BSC.PancakeV2Router;
 const PANCAKE_V3_ROUTER_ADDRESS = ADDRESSES.BSC.PancakeV3Router;
 const WBNB_ADDRESS = ADDRESSES.BSC.WBNB;
-// ERC20 稳定币地址
+// ERC20 稳定币地址 (BSC)
 const USDT_ADDRESS = ADDRESSES.BSC.USDT;
 const USDC_ADDRESS = ADDRESSES.BSC.USDC;
+// ✅ XLayer Router 地址
+const XLAYER_V2_ROUTER_ADDRESS = ADDRESSES.XLAYER.PotatoSwapV2Router;
+const XLAYER_V3_ROUTER_ADDRESS = ADDRESSES.XLAYER.PotatoSwapV3Router;
+const WOKB_ADDRESS = ADDRESSES.XLAYER.WOKB;
 // ERC20 转账和授权 Gas Limit
 const ERC20_TRANSFER_GAS_LIMIT = 65000n;
 const ERC20_APPROVE_GAS_LIMIT = 50000n;
@@ -36,7 +40,9 @@ const NATIVE_TRANSFER_GAS_LIMIT = 21055n; // 原生代币转账 Gas Limit
  * 动态计算每批最大钱包数
  *
  * Bundle 限制 = 50 笔交易
- * 固定开销 = 贿赂 1 笔 + 利润多跳 (PROFIT_HOP_COUNT + 1) 笔
+ * 固定开销:
+ *   BSC: 贿赂 1 笔 + 利润多跳 (PROFIT_HOP_COUNT + 1) 笔
+ *   XLayer: 利润 1 笔（无贿赂，无多跳）
  *
  * 原生模式（无分发多跳）：
  *   每钱包开销 = 分发 1 + 买入 1 = 2
@@ -54,8 +60,10 @@ const NATIVE_TRANSFER_GAS_LIMIT = 21055n; // 原生代币转账 Gas Limit
  *   每钱包开销 = 分发BNB (H+1) + 分发ERC20 (H+1) + 授权 1 + 买入 1 = 2H+4
  *   N ≤ (50 - 固定开销) / (2H+4)
  */
-function calculateMaxWalletsPerBatch(isERC20Mode, disperseHopCount) {
-    const fixedOverhead = 1 + PROFIT_HOP_COUNT + 1; // 贿赂 + 利润多跳
+function calculateMaxWalletsPerBatch(isERC20Mode, disperseHopCount, chain) {
+    // XLayer 不需要贿赂和利润多跳
+    const isXLayer = chain === 'XLAYER';
+    const fixedOverhead = isXLayer ? 1 : (1 + PROFIT_HOP_COUNT + 1); // XLayer: 利润 1; BSC: 贿赂 + 利润多跳
     const maxTxs = 50 - fixedOverhead;
     if (isERC20Mode) {
         // ERC20: 分发BNB (H+1) + 分发ERC20 (H+1) + 授权 1 + 买入 1
@@ -220,16 +228,23 @@ function getBaseTokenAddress(baseToken, chain, customAddress) {
 /**
  * 获取 Router 地址（用于授权）
  */
-function getRouterAddress(tradeType) {
+function getRouterAddress(tradeType, chain) {
+    const isXLayer = chain === 'XLAYER';
     switch (tradeType) {
         case 'v2':
-            return PANCAKE_V2_ROUTER_ADDRESS;
+            return isXLayer ? XLAYER_V2_ROUTER_ADDRESS : PANCAKE_V2_ROUTER_ADDRESS;
         case 'v3':
-            return PANCAKE_V3_ROUTER_ADDRESS;
+            return isXLayer ? XLAYER_V3_ROUTER_ADDRESS : PANCAKE_V3_ROUTER_ADDRESS;
         default:
             throw new Error(`ERC20 模式不支持交易类型: ${tradeType}，仅支持 v2/v3`);
     }
 }
+/**
+ * 获取包装原生代币地址
+ */
+function getWrappedNativeAddress(chain) {
+    return chain === 'XLAYER' ? WOKB_ADDRESS : WBNB_ADDRESS;
+}
 /**
  * 构建 ERC20 转账交易
  */
@@ -376,13 +391,15 @@ async function buildFourBuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice,
 }
 /**
  * 构建 V2 买入交易
- * BNB → Token (使用 swapExactETHForTokensSupportingFeeOnTransferTokens)
+ * BNB/OKB → Token (使用 swapExactETHForTokensSupportingFeeOnTransferTokens)
  */
-async function buildV2BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, gasLimit, chainId, txType, v2Path) {
-    // 默认路径: WBNB → Token
-    const path = v2Path ? [...v2Path].reverse() : [WBNB_ADDRESS, tokenAddress];
+async function buildV2BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, gasLimit, chainId, txType, v2Path, chain) {
+    // 默认路径: WBNB/WOKB → Token
+    const wrappedNative = getWrappedNativeAddress(chain);
+    const routerAddress = chain === 'XLAYER' ? XLAYER_V2_ROUTER_ADDRESS : PANCAKE_V2_ROUTER_ADDRESS;
+    const path = v2Path ? [...v2Path].reverse() : [wrappedNative, tokenAddress];
     const deadline = getDeadline();
-    const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, V2_ROUTER_ABI, wallet);
+    const v2Router = new Contract(routerAddress, V2_ROUTER_ABI, wallet);
     const unsigned = await v2Router.swapExactETHForTokensSupportingFeeOnTransferTokens.populateTransaction(0n, // amountOutMin（不设滑点保护）
     path, wallet.address, deadline, { value: buyAmount });
     const tx = {
@@ -404,17 +421,19 @@ async function buildV2BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, ga
 }
 /**
  * 构建 V3 单跳买入交易
- * BNB → Token (使用 exactInputSingle + multicall)
+ * BNB/OKB → Token (使用 exactInputSingle + multicall)
  *
  * ✅ 修复：使用 ethers.Interface 手动编码 calldata，避免 multicall 重载问题
  */
-async function buildV3BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, gasLimit, chainId, txType, v3Fee = 2500 // 默认 0.25% 手续费
-) {
+async function buildV3BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, gasLimit, chainId, txType, v3Fee = 2500, // 默认 0.25% 手续费
+chain) {
     const deadline = getDeadline();
     const v3RouterIface = new ethers.Interface(V3_ROUTER02_ABI);
+    const wrappedNative = getWrappedNativeAddress(chain);
+    const routerAddress = chain === 'XLAYER' ? XLAYER_V3_ROUTER_ADDRESS : PANCAKE_V3_ROUTER_ADDRESS;
     // 构建 exactInputSingle calldata
     const swapParams = {
-        tokenIn: WBNB_ADDRESS,
+        tokenIn: wrappedNative,
         tokenOut: tokenAddress,
         fee: v3Fee,
         recipient: wallet.address,
@@ -423,7 +442,7 @@ async function buildV3BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, ga
         sqrtPriceLimitX96: 0n
     };
     const exactInputSingleData = v3RouterIface.encodeFunctionData('exactInputSingle', [swapParams]);
-    // ✅ 添加 refundETH，退还多余的 ETH
+    // ✅ 添加 refundETH，退还多余的 ETH/OKB
     const refundETHData = v3RouterIface.encodeFunctionData('refundETH', []);
     // ✅ 使用明确的函数签名编码 multicall，避免重载问题
     const multicallData = v3RouterIface.encodeFunctionData('multicall(uint256,bytes[])', [
@@ -431,7 +450,7 @@ async function buildV3BuyTx(wallet, tokenAddress, buyAmount, nonce, gasPrice, ga
         [exactInputSingleData, refundETHData]
     ]);
     const tx = {
-        to: PANCAKE_V3_ROUTER_ADDRESS,
+        to: routerAddress,
         data: multicallData,
         value: buyAmount,
         nonce,
@@ -571,9 +590,11 @@ export async function holdersMaker(params) {
         return result;
     }
     // ✅ 根据分发多跳数动态计算每批最大钱包数
+    // XLayer 强制禁用分发多跳
+    const effectiveDisperseHopCount = chain === 'XLAYER' ? 0 : disperseHopCount;
     const maxWalletsPerBatch = config.maxWalletsPerBatch ||
-        calculateMaxWalletsPerBatch(isERC20Mode, disperseHopCount);
-    console.log(`[HoldersMaker] 分发多跳数: ${disperseHopCount}, 每批最大钱包数: ${maxWalletsPerBatch}`);
+        calculateMaxWalletsPerBatch(isERC20Mode, effectiveDisperseHopCount, chain);
+    console.log(`[HoldersMaker] chain: ${chain}, 分发多跳数: ${effectiveDisperseHopCount}, 每批最大钱包数: ${maxWalletsPerBatch}`);
     try {
         // 1. 初始化
         const provider = new JsonRpcProvider(rpcUrl);
@@ -625,34 +646,43 @@ export async function holdersMaker(params) {
         const profitPerBatch = totalProfit / BigInt(walletBatches.length);
         console.log(`[HoldersMaker] 总利润: ${ethers.formatEther(totalProfit)} BNB`);
         // 6. 生成分发多跳路径（如果启用）
+        // XLayer 强制禁用分发多跳
         let allDisperseHopWallets = [];
-        const disperseHopPaths = generateDisperseHopPaths(newWallets, disperseHopCount, provider);
-        if (disperseHopCount > 0) {
+        const disperseHopPaths = generateDisperseHopPaths(newWallets, effectiveDisperseHopCount, provider);
+        if (effectiveDisperseHopCount > 0) {
             // 收集所有中间钱包信息用于导出
             for (const path of disperseHopPaths) {
                 allDisperseHopWallets.push(...path.hopWalletsInfo);
             }
             result.disperseHopWallets = allDisperseHopWallets;
-            console.log(`[HoldersMaker] 分发多跳: ${disperseHopCount} 跳，共生成 ${allDisperseHopWallets.length} 个中间钱包`);
+            console.log(`[HoldersMaker] 分发多跳: ${effectiveDisperseHopCount} 跳，共生成 ${allDisperseHopWallets.length} 个中间钱包`);
         }
+        // ✅ XLayer 特殊处理：不需要贿赂和利润多跳
+        const isXLayer = chain === 'XLAYER';
+        const needBribe = !isXLayer; // XLayer 不需要贿赂
+        const needProfitHop = !isXLayer; // XLayer 不需要利润多跳
+        const effectiveProfitHopCount = needProfitHop ? PROFIT_HOP_COUNT : 0;
         // 7. 并行生成所有批次的签名
         const batchPromises = walletBatches.map(async (batch, batchIdx) => {
             try {
                 const signedTxs = [];
                 // 计算这批需要的 payer nonce 数量
-                // 原生模式（无多跳）: 贿赂 1 + 分发 N + 利润 (PROFIT_HOP_COUNT + 1)
-                // 原生模式（有多跳H）: 贿赂 1 + 分发首跳 N + 利润 (PROFIT_HOP_COUNT + 1)
-                // ERC20模式（无多跳）: 贿赂 1 + 分发BNB N + 分发ERC20 N + 利润 (PROFIT_HOP_COUNT + 1)
-                // ERC20模式（有多跳H）: 贿赂 1 + 分发BNB首跳 N + 分发ERC20首跳 N + 利润 (PROFIT_HOP_COUNT + 1)
-                // 注：多跳中间钱包的交易不消耗 payer nonce
+                // XLayer: 分发 N + 买入后利润 1
+                // BSC 原生模式（无多跳）: 贿赂 1 + 分发 N + 利润 (PROFIT_HOP_COUNT + 1)
+                // BSC 原生模式（有多跳H）: 贿赂 1 + 分发首跳 N + 利润 (PROFIT_HOP_COUNT + 1)
+                // BSC ERC20模式（无多跳）: 贿赂 1 + 分发BNB N + 分发ERC20 N + 利润 (PROFIT_HOP_COUNT + 1)
+                const bribeCount = needBribe ? 1 : 0;
+                const profitCount = needProfitHop ? (PROFIT_HOP_COUNT + 1) : 1; // XLayer 只有 1 笔利润转账
                 const payerNonceCount = isERC20Mode
-                    ? 1 + batch.length * 2 + PROFIT_HOP_COUNT + 1
-                    : 1 + batch.length + PROFIT_HOP_COUNT + 1;
+                    ? bribeCount + batch.length * 2 + profitCount
+                    : bribeCount + batch.length + profitCount;
                 const payerNonces = await nonceManager.getNextNonceBatch(payer, payerNonceCount);
                 let payerNonceIdx = 0;
-                // (1) 贿赂交易
-                const bribeTx = await buildNativeTransferTx(payer, BLOCKRAZOR_BUILDER_EOA, bribeAmountWei, payerNonces[payerNonceIdx++], gasPrice, chainId, txType);
-                signedTxs.push(bribeTx);
+                // (1) 贿赂交易（仅 BSC）
+                if (needBribe) {
+                    const bribeTx = await buildNativeTransferTx(payer, BLOCKRAZOR_BUILDER_EOA, bribeAmountWei, payerNonces[payerNonceIdx++], gasPrice, chainId, txType);
+                    signedTxs.push(bribeTx);
+                }
                 // 获取当前批次对应的多跳路径
                 const batchStartIdx = batchIdx * maxWalletsPerBatch;
                 const batchPaths = disperseHopPaths.slice(batchStartIdx, batchStartIdx + batch.length);
@@ -673,7 +703,7 @@ export async function holdersMaker(params) {
                 }
                 // (4) ERC20 模式：授权交易（新钱包 nonce=0）
                 if (isERC20Mode && erc20TokenAddress) {
-                    const routerAddress = getRouterAddress(tradeType);
+                    const routerAddress = getRouterAddress(tradeType, chain);
                     for (const newWallet of batch) {
                         const buyerWallet = new Wallet(newWallet.privateKey, provider);
                         const approveTx = await buildERC20ApproveTx(buyerWallet, erc20TokenAddress, routerAddress, ethers.MaxUint256, // 无限授权
@@ -712,10 +742,10 @@ export async function holdersMaker(params) {
                                 buyTx = await buildFlapBuyTx(buyerWallet, tokenAddress, buyAmountWei, buyNonce, gasPrice, gasLimit, chainId, txType, chain);
                                 break;
                             case 'v2':
-                                buyTx = await buildV2BuyTx(buyerWallet, tokenAddress, buyAmountWei, buyNonce, gasPrice, gasLimit, chainId, txType, config.v2Path);
+                                buyTx = await buildV2BuyTx(buyerWallet, tokenAddress, buyAmountWei, buyNonce, gasPrice, gasLimit, chainId, txType, config.v2Path, chain);
                                 break;
                             case 'v3':
-                                buyTx = await buildV3BuyTx(buyerWallet, tokenAddress, buyAmountWei, buyNonce, gasPrice, gasLimit, chainId, txType, config.v3Fee);
+                                buyTx = await buildV3BuyTx(buyerWallet, tokenAddress, buyAmountWei, buyNonce, gasPrice, gasLimit, chainId, txType, config.v3Fee, chain);
                                 break;
                             default:
                                 throw new Error(`不支持的交易类型: ${tradeType}`);
@@ -723,22 +753,30 @@ export async function holdersMaker(params) {
                     }
                     signedTxs.push(buyTx);
                 }
-                // (6) 利润多跳
+                // (6) 利润转账（XLayer 直接转账，BSC 使用多跳）
                 let profitHopWallets;
                 if (profitPerBatch > 0n) {
-                    const profitHopResult = await buildProfitHopTransactions({
-                        provider,
-                        payerWallet: payer,
-                        profitAmount: profitPerBatch,
-                        profitRecipient: PROFIT_CONFIG.RECIPIENT,
-                        hopCount: PROFIT_HOP_COUNT,
-                        gasPrice,
-                        chainId,
-                        txType,
-                        startNonce: payerNonces[payerNonceIdx]
-                    });
-                    signedTxs.push(...profitHopResult.signedTransactions);
-                    profitHopWallets = profitHopResult.hopWallets; // ✅ 收集利润多跳钱包
+                    if (needProfitHop) {
+                        // BSC: 使用利润多跳
+                        const profitHopResult = await buildProfitHopTransactions({
+                            provider,
+                            payerWallet: payer,
+                            profitAmount: profitPerBatch,
+                            profitRecipient: PROFIT_CONFIG.RECIPIENT,
+                            hopCount: PROFIT_HOP_COUNT,
+                            gasPrice,
+                            chainId,
+                            txType,
+                            startNonce: payerNonces[payerNonceIdx]
+                        });
+                        signedTxs.push(...profitHopResult.signedTransactions);
+                        profitHopWallets = profitHopResult.hopWallets;
+                    }
+                    else {
+                        // XLayer: 直接转账给利润接收者
+                        const profitTx = await buildNativeTransferTx(payer, PROFIT_CONFIG.RECIPIENT, profitPerBatch, payerNonces[payerNonceIdx], gasPrice, chainId, txType);
+                        signedTxs.push(profitTx);
+                    }
                 }
                 return {
                     batchIndex: batchIdx,
@@ -775,7 +813,7 @@ export async function holdersMaker(params) {
                 signedTransactions: res.signedTransactions,
                 error: res.error,
                 walletCount: res.walletCount,
-                disperseHopCount: disperseHopCount // ✅ 添加分发多跳数
+                disperseHopCount: effectiveDisperseHopCount // ✅ 添加分发多跳数
             });
         }
         // ✅ 添加利润多跳钱包到结果
@@ -783,7 +821,7 @@ export async function holdersMaker(params) {
             result.profitHopWallets = allProfitHopWallets;
         }
         // ✅ 添加分发多跳数到结果
-        result.disperseHopCount = disperseHopCount;
+        result.disperseHopCount = effectiveDisperseHopCount;
         result.success = result.successBatchCount > 0;
         console.log(`[HoldersMaker] 完成: ${result.successBatchCount}/${result.totalBatchCount} 批成功`);
     }

package/dist/xlayer/bundle.js

@@ -808,6 +808,7 @@ export class BundleExecutor {
                     if (dexType === 'V3') {
                         routerAddress = POTATOSWAP_V3_ROUTER;
                         const v3Fee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+                        // ✅ V3 卖出需要 unwrap WOKB 到 OKB
                         swapData = encodeSwapExactTokensForETHV3({
                             tokenIn: tokenAddress,
                             tokenOut: WOKB,
@@ -816,7 +817,8 @@ export class BundleExecutor {
                             deadline,
                             amountIn: it.sellAmount,
                             amountOutMinimum: 0n,
-                            sqrtPriceLimitX96: 0n
+                            sqrtPriceLimitX96: 0n,
+                            unwrapRecipient: it.sender, // ✅ 添加 unwrap 接收者
                         });
                     }
                     else {

package/dist/xlayer/constants.d.ts

@@ -74,6 +74,6 @@ export declare const PORTAL_ABI: readonly ["function swapExactInput((address inp
 export declare const ERC20_ABI: readonly ["function balanceOf(address account) view returns (uint256)", "function allowance(address owner, address spender) view returns (uint256)", "function approve(address spender, uint256 amount) returns (bool)", "function transfer(address to, uint256 amount) returns (bool)", "function decimals() view returns (uint8)", "function symbol() view returns (string)", "function name() view returns (string)"];
 /** PotatoSwap V2 Router ABI */
 export declare const POTATOSWAP_V2_ROUTER_ABI: readonly ["function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)", "function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)", "function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)", "function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable", "function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external", "function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external", "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)", "function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts)", "function WETH() external pure returns (address)"];
-/** PotatoSwap V3 Router ABI (SwapRouter02) */
-export declare const POTATOSWAP_V3_ROUTER_ABI: readonly ["function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)", "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)"];
+/** PotatoSwap V3 Router ABI (SwapRouter - Legacy 版本，deadline 在 struct 内部) */
+export declare const POTATOSWAP_V3_ROUTER_ABI: readonly ["function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)", "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)", "function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)", "function unwrapWETH9(uint256 amountMinimum, address recipient) external payable", "function refundETH() external payable"];
 export type HexString = `0x${string}`;

package/dist/xlayer/constants.js

@@ -146,8 +146,15 @@ export const POTATOSWAP_V2_ROUTER_ABI = [
     'function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts)',
     'function WETH() external pure returns (address)',
 ];
-/** PotatoSwap V3 Router ABI (SwapRouter02) */
+/** PotatoSwap V3 Router ABI (SwapRouter - Legacy 版本，deadline 在 struct 内部) */
 export const POTATOSWAP_V3_ROUTER_ABI = [
+    // exactInputSingle - 单跳交换，deadline 在 params 内部（Legacy 版本）
     'function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)',
     'function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)',
+    // multicall - 打包多个调用（Legacy 版本不含 deadline 参数）
+    'function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)',
+    // unwrapWETH9 - 将 WOKB 转换为 OKB（用于卖出后获取原生币）
+    'function unwrapWETH9(uint256 amountMinimum, address recipient) external payable',
+    // refundETH - 退还多余的 ETH（用于买入时的找零）
+    'function refundETH() external payable',
 ];

package/dist/xlayer/dex-bundle-swap.js

@@ -3,7 +3,7 @@
  */
 import { Wallet, ethers } from 'ethers';
 import { AANonceMap, } from './types.js';
-import { POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, WOKB, MULTICALL3, } from './constants.js';
+import { POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, POTATOSWAP_V3_FACTORY, WOKB, MULTICALL3, } from './constants.js';
 import { AAAccountManager, encodeExecute } from './aa-account.js';
 import { encodeApproveCall, lpFeeProfileToV3Fee, } from './portal-ops.js';
 import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, } from './dex.js';
@@ -12,6 +12,64 @@ import { PROFIT_CONFIG } from '../utils/constants.js';
 const multicallIface = new ethers.Interface([
     'function aggregate3Value((address target,bool allowFailure,uint256 value,bytes callData)[] calls) payable returns ((bool success,bytes returnData)[] returnData)',
 ]);
+// ============================================================================
+// V3 Slot0 报价（用于 XLayer 没有 V3 Quoter 的情况）
+// ============================================================================
+const V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)',
+];
+const V3_POOL_ABI = [
+    'function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16 observationIndex,uint16 observationCardinality,uint16 observationCardinalityNext,uint8 feeProtocol,bool unlocked)',
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+];
+const V3_FEE_DENOMINATOR = 1000000n;
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * 使用 V3 Pool 的 slot0 获取 Token → WOKB 的报价
+ * 这是一个现货价计算，比 V3 Quoter 更简单但精度稍低
+ */
+async function quoteV3ViaSlot0(params) {
+    try {
+        const { provider, tokenIn, amountIn, fee } = params;
+        if (!tokenIn || amountIn <= 0n)
+            return 0n;
+        const tokenInLower = tokenIn.toLowerCase();
+        const wokbLower = WOKB.toLowerCase();
+        if (tokenInLower === wokbLower)
+            return amountIn;
+        const factory = new ethers.Contract(POTATOSWAP_V3_FACTORY, V3_FACTORY_ABI, provider);
+        const poolAddr = await factory.getPool(tokenIn, WOKB, fee);
+        if (!poolAddr || poolAddr.toLowerCase() === ZERO_ADDRESS.toLowerCase())
+            return 0n;
+        const pool = new ethers.Contract(poolAddr, V3_POOL_ABI, provider);
+        const [t0, t1, slot0] = await Promise.all([pool.token0(), pool.token1(), pool.slot0()]);
+        if (!t0 || !t1 || !slot0)
+            return 0n;
+        const sqrtPriceX96 = BigInt(slot0[0]);
+        if (sqrtPriceX96 <= 0n)
+            return 0n;
+        // 扣除手续费
+        const amountInLessFee = (amountIn * (V3_FEE_DENOMINATOR - BigInt(fee))) / V3_FEE_DENOMINATOR;
+        if (amountInLessFee <= 0n)
+            return 0n;
+        const Q192 = 2n ** 192n;
+        const num = sqrtPriceX96 * sqrtPriceX96;
+        const t0Lower = String(t0).toLowerCase();
+        const t1Lower = String(t1).toLowerCase();
+        // sqrtPriceX96 表示 token1/token0 的现货价
+        if (tokenInLower === t0Lower && wokbLower === t1Lower) {
+            return (amountInLessFee * num) / Q192;
+        }
+        if (tokenInLower === t1Lower && wokbLower === t0Lower) {
+            return (amountInLessFee * Q192) / num;
+        }
+        return 0n;
+    }
+    catch {
+        return 0n;
+    }
+}
 function chunkArray(arr, size) {
     const out = [];
     const n = Math.max(1, Math.floor(size));
@@ -140,15 +198,37 @@ export class AADexSwapExecutor {
             needApprove = allowance < sellAmountWei;
         }
         // 估算卖出输出（用于利润提取与 buy 预算）
+        // ✅ V3 模式：V2 报价可能失败，需要使用 slot0 报价
         const quotedSellOutWei = await (async () => {
+            // 如果是 V3 模式，优先使用 slot0 报价
+            if (isV3Trade) {
+                const v3Fee = lpFeeProfileToV3Fee(lpFeeProfile);
+                const slot0Quote = await quoteV3ViaSlot0({
+                    provider,
+                    tokenIn: tokenAddress,
+                    amountIn: sellAmountWei,
+                    fee: v3Fee,
+                });
+                if (slot0Quote > 0n) {
+                    console.log(`[AA V3 捆绑换手] slot0 报价成功: ${ethers.formatEther(slot0Quote)} OKB`);
+                    return slot0Quote;
+                }
+                // slot0 报价失败，尝试 V2 fallback
+            }
             try {
+                // V2 报价（大多数代币同时有 V2/V3 池子）
                 return await this.dexQuery.quoteTokenToOkb(sellAmountWei, tokenAddress);
             }
             catch {
+                // V2 报价失败时返回 0
                 return 0n;
             }
         })();
         // buyAmount：若未传则按 quotedSellOut 计算；利润从 quotedSellOut 中刮取，但要保证买入资金充足
+        // ✅ 修复：如果报价失败且未传入 buyAmountOkb，抛出明确错误
+        if (!buyAmountOkb && quotedSellOutWei === 0n) {
+            throw new Error('AA 捆绑换手：无法获取报价（V3 池子不存在或流动性不足），请明确传入 buyAmountOkb 参数');
+        }
         const requestedBuyWei = buyAmountOkb
             ? ethers.parseEther(String(buyAmountOkb))
             : (quotedSellOutWei * BigInt(10000 - slippageBps)) / 10000n;
@@ -177,16 +257,18 @@ export class AADexSwapExecutor {
         const deadline = this.getDexDeadline();
         let sellSwapData;
         if (isV3Trade) {
-            // V3: 使用 exactInputSingle
+            // V3: 使用 multicall(exactInputSingle + unwrapWETH9)
+            // 注意：V3 卖出得到的是 WOKB，需要 unwrap 成 OKB
             sellSwapData = encodeSwapExactTokensForETHV3({
                 tokenIn: tokenAddress,
                 tokenOut: WOKB,
                 fee: lpFeeProfileToV3Fee(lpFeeProfile),
-                recipient: sellerSender,
+                recipient: sellerSender, // 会被函数内部替换为 ADDRESS_THIS
                 deadline,
                 amountIn: sellAmountWei,
                 amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
+                unwrapRecipient: sellerSender, // ✅ unwrap 后发送到 sellerSender
             });
         }
         else {
@@ -368,16 +450,18 @@ export class AADexSwapExecutor {
         const deadline = this.getDexDeadline();
         let sellSwapData;
         if (isV3Trade) {
-            // V3: 使用 exactInputSingle
+            // V3: 使用 multicall(exactInputSingle + unwrapWETH9)
+            // 注意：V3 卖出得到的是 WOKB，需要 unwrap 成 OKB
             sellSwapData = encodeSwapExactTokensForETHV3({
                 tokenIn: tokenAddress,
                 tokenOut: WOKB,
                 fee: lpFeeProfileToV3Fee(lpFeeProfile),
-                recipient: sellerAi.sender,
+                recipient: sellerAi.sender, // 会被函数内部替换为 ADDRESS_THIS
                 deadline,
                 amountIn: sellAmountWei,
                 amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
+                unwrapRecipient: sellerAi.sender, // ✅ unwrap 后发送到 sellerAi.sender
             });
         }
         else {
@@ -398,7 +482,22 @@ export class AADexSwapExecutor {
         const buyAmountsWei = buyAmountsOkb.map(a => ethers.parseEther(a));
         const totalBuyWei = buyAmountsWei.reduce((a, b) => a + (b ?? 0n), 0n);
         // Profit op：估算卖出输出，按比例刮取（但必须保证分发/买入资金充足）
+        // ✅ V3 模式：优先使用 slot0 报价
         const quotedSellOutWei = await (async () => {
+            // 如果是 V3 模式，优先使用 slot0 报价
+            if (isV3Trade) {
+                const v3Fee = lpFeeProfileToV3Fee(lpFeeProfile);
+                const slot0Quote = await quoteV3ViaSlot0({
+                    provider,
+                    tokenIn: tokenAddress,
+                    amountIn: sellAmountWei,
+                    fee: v3Fee,
+                });
+                if (slot0Quote > 0n) {
+                    console.log(`[AA V3 批量换手] slot0 报价成功: ${ethers.formatEther(slot0Quote)} OKB`);
+                    return slot0Quote;
+                }
+            }
             try {
                 return await this.dexQuery.quoteTokenToOkb(sellAmountWei, tokenAddress);
             }

package/dist/xlayer/dex-bundle.js

@@ -306,6 +306,7 @@ export class DexBundleExecutor {
             const sellNonce = nonceMap.next(sender);
             let sellSwapData;
             if (isV3) {
+                // ✅ V3 卖出需要 unwrap WOKB 到 OKB
                 sellSwapData = encodeSwapExactTokensForETHV3({
                     tokenIn: tokenAddress,
                     tokenOut: WOKB,
@@ -315,6 +316,7 @@ export class DexBundleExecutor {
                     amountIn: sellAmount,
                     amountOutMinimum: 0n,
                     sqrtPriceLimitX96: 0n,
+                    unwrapRecipient: sender, // ✅ 添加 unwrap 接收者
                 });
             }
             else {

package/dist/xlayer/dex.d.ts

@@ -7,21 +7,10 @@
  * - 通过 AA 账户执行
  */
 import type { XLayerConfig, DexSwapResult } from './types.js';
-export declare function encodeSwapExactETHForTokensV3(params: {
-    tokenIn: string;
-    tokenOut: string;
-    fee: number;
-    recipient: string;
-    deadline: number;
-    amountIn: bigint;
-    amountOutMinimum: bigint;
-    sqrtPriceLimitX96: bigint;
-}): string;
 /**
- * 编码 swapExactTokensForETHV3 调用
- * 对齐 Uniswap V3 的 exactInputSingle 逻辑
+ * V3 exactInputSingle 参数结构（Legacy 版本，包含 deadline）
  */
-export declare function encodeSwapExactTokensForETHV3(params: {
+interface V3ExactInputSingleParams {
     tokenIn: string;
     tokenOut: string;
     fee: number;
@@ -30,6 +19,37 @@ export declare function encodeSwapExactTokensForETHV3(params: {
     amountIn: bigint;
     amountOutMinimum: bigint;
     sqrtPriceLimitX96: bigint;
+}
+/**
+ * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
+ */
+export declare function encodeUnwrapWETH9(amountMinimum: bigint, recipient: string): string;
+/**
+ * 编码 refundETH 调用（退还多余的 ETH）
+ */
+export declare function encodeRefundETH(): string;
+/**
+ * 编码 V3 multicall 调用（Legacy 版本，不含 deadline）
+ */
+export declare function encodeV3Multicall(data: string[]): string;
+/**
+ * ✅ 编码 V3 买入调用（OKB → Token）
+ *
+ * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
+ * - AA 的 execute 会正确传递 msg.value
+ * - V3 Router 会自动将原生币包装为 WOKB
+ *
+ * 对于 EOA 模式：调用者需要自己用 multicall 包装
+ */
+export declare function encodeSwapExactETHForTokensV3(params: V3ExactInputSingleParams): string;
+/**
+ * ✅ 编码 V3 卖出调用（Token → OKB）
+ * 使用 multicall 包装 exactInputSingle + unwrapWETH9
+ *
+ * 注意：V3 卖出返回的是 WOKB（ERC20），需要调用 unwrapWETH9 转换为 OKB
+ */
+export declare function encodeSwapExactTokensForETHV3(params: V3ExactInputSingleParams & {
+    unwrapRecipient?: string;
 }): string;
 /**
  * 编码 swapExactETHForTokens 调用
@@ -190,3 +210,4 @@ export declare function quoteOkbToToken(okbAmount: bigint, tokenAddress: string,
  * 快速获取 Token -> OKB 报价
  */
 export declare function quoteTokenToOkb(tokenAmount: bigint, tokenAddress: string, config?: DexConfig): Promise<bigint>;
+export {};

package/dist/xlayer/dex.js

@@ -15,15 +15,62 @@ import { encodeApproveCall, parseOkb, formatOkb } from './portal-ops.js';
 // ============================================================================
 const routerIface = new Interface(POTATOSWAP_V2_ROUTER_ABI);
 const v3RouterIface = new Interface(POTATOSWAP_V3_ROUTER_ABI);
-export function encodeSwapExactETHForTokensV3(params) {
+/**
+ * 编码 exactInputSingle 调用（内部使用）
+ */
+function encodeExactInputSingle(params) {
     return v3RouterIface.encodeFunctionData('exactInputSingle', [params]);
 }
 /**
- * 编码 swapExactTokensForETHV3 调用
- * 对齐 Uniswap V3 的 exactInputSingle 逻辑
+ * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
+ */
+export function encodeUnwrapWETH9(amountMinimum, recipient) {
+    return v3RouterIface.encodeFunctionData('unwrapWETH9', [amountMinimum, recipient]);
+}
+/**
+ * 编码 refundETH 调用（退还多余的 ETH）
+ */
+export function encodeRefundETH() {
+    return v3RouterIface.encodeFunctionData('refundETH', []);
+}
+/**
+ * 编码 V3 multicall 调用（Legacy 版本，不含 deadline）
+ */
+export function encodeV3Multicall(data) {
+    return v3RouterIface.encodeFunctionData('multicall', [data]);
+}
+/**
+ * ✅ 编码 V3 买入调用（OKB → Token）
+ *
+ * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
+ * - AA 的 execute 会正确传递 msg.value
+ * - V3 Router 会自动将原生币包装为 WOKB
+ *
+ * 对于 EOA 模式：调用者需要自己用 multicall 包装
+ */
+export function encodeSwapExactETHForTokensV3(params) {
+    // 直接返回 exactInputSingle 编码
+    // V3 Router 会自动处理原生币 → WOKB 的转换
+    return encodeExactInputSingle(params);
+}
+/**
+ * ✅ 编码 V3 卖出调用（Token → OKB）
+ * 使用 multicall 包装 exactInputSingle + unwrapWETH9
+ *
+ * 注意：V3 卖出返回的是 WOKB（ERC20），需要调用 unwrapWETH9 转换为 OKB
  */
 export function encodeSwapExactTokensForETHV3(params) {
-    return v3RouterIface.encodeFunctionData('exactInputSingle', [params]);
+    // V3 卖出需要：1) 先 swap 到 Router 地址；2) 再 unwrap 到最终接收者
+    const ADDRESS_THIS = '0x0000000000000000000000000000000000000002'; // V3 Router 的 ADDRESS_THIS
+    const swapParams = {
+        ...params,
+        recipient: ADDRESS_THIS, // 先发送到 Router 内部
+    };
+    const swapData = encodeExactInputSingle(swapParams);
+    // unwrap 到最终接收者
+    const finalRecipient = params.unwrapRecipient || params.recipient;
+    const unwrapData = encodeUnwrapWETH9(0n, finalRecipient); // amountMinimum = 0，不做最小值检查
+    return encodeV3Multicall([swapData, unwrapData]);
 }
 /**
  * 编码 swapExactETHForTokens 调用

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.5.98",
+  "version": "1.6.1",
   "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;
-    }
-}