four-flap-meme-sdk 1.5.96 → 1.5.99

package/dist/contracts/tm-bundle-merkle/index.d.ts

@@ -9,6 +9,7 @@ export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle,
 export { disperseWithBundleMerkle, sweepWithBundleMerkle, pairwiseTransferWithBundleMerkle } from './utils.js';
 export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approveFourPancakeProxy, approveFourPancakeProxyBatch } from './pancake-proxy.js';
 export { approveFourTokenManagerBatch, type ApproveFourTokenManagerBatchParams, type ApproveFourTokenManagerBatchResult } from './approve-tokenmanager.js';
-export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, type MerkleSubmitConfig, type SubmitBundleResult, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, type BlockRazorSubmitConfig, type BlockRazorSubmitResult, submitDirectToRpc, submitDirectToRpcSequential, // ✅ 新增：顺序广播并等待确认（用于多跳）
+export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, type MerkleSubmitConfig, type SubmitBundleResult, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, type BlockRazorSubmitConfig, type BlockRazorSubmitResult, submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
+submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
 submitDirectToRpcParallel, type DirectSubmitConfig, type DirectSubmitResult, type DirectTxResult } from './submit.js';
 export { fourBundleBuyFirstMerkle, type FourBundleBuyFirstSignParams, type FourBuyFirstSignConfig, type FourBuyFirstResult } from './swap-buy-first.js';

package/dist/contracts/tm-bundle-merkle/index.js

@@ -22,7 +22,8 @@ submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel,
 // ✅ BlockRazor 提交方法
 submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, 
 // ✅ Monad 等链的逐笔广播方法
-submitDirectToRpc, submitDirectToRpcSequential, // ✅ 新增：顺序广播并等待确认（用于多跳）
+submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
+submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
 submitDirectToRpcParallel } from './submit.js';
 // 先买后卖换手方法
 export { fourBundleBuyFirstMerkle } from './swap-buy-first.js';

package/dist/contracts/tm-bundle-merkle/submit.d.ts

@@ -260,6 +260,17 @@ export declare function submitDirectToRpc(signedTransactions: string[], config:
  * @returns 广播结果
  */
 export declare function submitDirectToRpcSequential(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
+/**
+ * ✅ 顺序广播但不等待确认（用于 AA handleOps + tail 等 nonce 连续的场景）
+ *
+ * 按顺序逐笔发送交易，每笔只等待广播成功（RPC 返回 txHash），不等待链上确认。
+ * 这样可以保证交易按顺序进入 mempool，同时避免等待确认超时。
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param config 直接广播配置
+ * @returns 广播结果
+ */
+export declare function submitDirectToRpcSequentialNoWait(signedTransactions: string[], config: DirectSubmitConfig): Promise<DirectSubmitResult>;
 /**
  * 并行逐笔广播到 RPC（速度更快，但可能有 nonce 冲突）
  *

package/dist/contracts/tm-bundle-merkle/submit.js

@@ -510,6 +510,94 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
         errorSummary: errors.length > 0 ? errors.join('; ') : undefined
     };
 }
+/**
+ * ✅ 顺序广播但不等待确认（用于 AA handleOps + tail 等 nonce 连续的场景）
+ *
+ * 按顺序逐笔发送交易，每笔只等待广播成功（RPC 返回 txHash），不等待链上确认。
+ * 这样可以保证交易按顺序进入 mempool，同时避免等待确认超时。
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param config 直接广播配置
+ * @returns 广播结果
+ */
+export async function submitDirectToRpcSequentialNoWait(signedTransactions, config) {
+    const totalTransactions = signedTransactions?.length ?? 0;
+    if (!signedTransactions || signedTransactions.length === 0) {
+        return {
+            code: false,
+            totalTransactions: 0,
+            successCount: 0,
+            failedCount: 0,
+            txHashes: [],
+            results: [],
+            errorSummary: 'signedTransactions cannot be empty'
+        };
+    }
+    if (!config.rpcUrl) {
+        return {
+            code: false,
+            totalTransactions,
+            successCount: 0,
+            failedCount: totalTransactions,
+            txHashes: [],
+            results: [],
+            errorSummary: 'rpcUrl is required in config'
+        };
+    }
+    const chainId = config.chainId ?? 143;
+    const chainName = config.chainName ?? 'MONAD';
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+        chainId,
+        name: chainName
+    });
+    const results = [];
+    const txHashes = [];
+    const errors = [];
+    // ✅ 顺序广播，每笔只等待广播成功（不等待链上确认）
+    for (let i = 0; i < signedTransactions.length; i++) {
+        const signedTx = signedTransactions[i];
+        try {
+            // 广播交易，等待 RPC 返回 txHash
+            const txResponse = await provider.broadcastTransaction(signedTx);
+            results.push({
+                index: i,
+                success: true,
+                txHash: txResponse.hash
+            });
+            txHashes.push(txResponse.hash);
+            console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播成功: ${txResponse.hash}`);
+        }
+        catch (error) {
+            const errorMessage = error?.message || String(error);
+            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播失败:`, errorMessage);
+            // ✅ 兼容：nonce too low / already known 等情况下，交易可能已经被接收
+            const recovered = await recoverTxHashIfAlreadySeen(provider, signedTx, errorMessage);
+            if (recovered) {
+                results.push({ index: i, success: true, txHash: recovered, error: errorMessage });
+                txHashes.push(recovered);
+                continue;
+            }
+            results.push({
+                index: i,
+                success: false,
+                error: errorMessage
+            });
+            errors.push(`交易 ${i + 1}: ${errorMessage}`);
+            // ✅ 如果某笔失败，继续尝试后续交易（可能是 nonce 问题可以自动恢复）
+        }
+    }
+    const successCount = txHashes.length;
+    const failedCount = totalTransactions - successCount;
+    return {
+        code: successCount > 0,
+        totalTransactions,
+        successCount,
+        failedCount,
+        txHashes,
+        results,
+        errorSummary: errors.length > 0 ? errors.join('; ') : undefined
+    };
+}
 /**
  * 并行逐笔广播到 RPC（速度更快，但可能有 nonce 冲突）
  *

package/dist/index.d.ts

@@ -49,7 +49,8 @@ export { flapBundleCurveToDex, type CurveToDexChain, type DexPoolType, type Curv
 export { flapBundleCreateToDex, type CreateToDexChain, type CreateToDexSignConfig, type CreateTokenInfo, type FlapCreateToDexParams, type FlapCreateToDexResult } from './flap/portal-bundle-merkle/create-to-dex.js';
 export { PROFIT_CONFIG } from './utils/constants.js';
 export { quoteV2, quoteV3, quote, getTokenToNativeQuote, getNativeToTokenQuote, getWrappedNativeAddress, getStableCoins, V3_FEE_TIERS, QUOTE_CONFIG, type QuoteParams, type QuoteResult, type SupportedChain, } from './utils/quote-helpers.js';
-export { submitDirectToRpc, submitDirectToRpcSequential, // ✅ 新增：顺序广播并等待确认（用于多跳）
+export { submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
+submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
 submitDirectToRpcParallel, type DirectSubmitConfig, type DirectSubmitResult, type DirectTxResult } from './contracts/tm-bundle-merkle/submit.js';
 export { directV2BatchBuy, directV2BatchSell, directV3BatchBuy, directV3BatchSell, getRouterAddress, DIRECT_ROUTERS, type DirectV2BuyParams, type DirectV2SellParams, type DirectV3BuyParams, type DirectV3SellParams, type DirectRouterResult, type DirectRouterSignConfig, type DexKey, type RouterVersion, } from './dex/index.js';
 export * as XLayer from './xlayer/index.js';

package/dist/index.js

@@ -82,7 +82,8 @@ export { PROFIT_CONFIG } from './utils/constants.js';
 // ✅ V2/V3 报价工具（统一管理）
 export { quoteV2, quoteV3, quote, getTokenToNativeQuote, getNativeToTokenQuote, getWrappedNativeAddress, getStableCoins, V3_FEE_TIERS, QUOTE_CONFIG, } from './utils/quote-helpers.js';
 // ✅ Monad 等不支持 Bundle 的链：逐笔 RPC 广播方法（服务器端使用）
-export { submitDirectToRpc, submitDirectToRpcSequential, // ✅ 新增：顺序广播并等待确认（用于多跳）
+export { submitDirectToRpc, submitDirectToRpcSequential, // ✅ 顺序广播并等待确认（用于多跳）
+submitDirectToRpcSequentialNoWait, // ✅ 顺序广播但不等待确认（用于 AA handleOps + tail）
 submitDirectToRpcParallel } from './contracts/tm-bundle-merkle/submit.js';
 // ============================================================
 // ✅ DEX 直接交易（不走代理合约）

package/dist/xlayer/bundle.js

@@ -10,7 +10,7 @@
 import { Wallet, Interface, Contract, ethers } from 'ethers';
 import { FLAP_PORTAL, ENTRYPOINT_ABI, PORTAL_ABI, DEFAULT_CALL_GAS_LIMIT_SELL, DEFAULT_WITHDRAW_RESERVE, WOKB, POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, } from './constants.js';
 import { AAAccountManager, encodeExecute, encodeExecuteBatch, createWallet } from './aa-account.js';
-import { encodeBuyCall, encodeBuyCallV3, encodeSellCall, encodeApproveCall, encodeTransferCall, encodeCreateCallV2, encodeCreateCallV3, encodeCreateCallV4, PortalQuery, parseOkb, formatOkb, lpFeeProfileToV3Fee, } from './portal-ops.js';
+import { encodeBuyCallV3, encodeSellCall, encodeApproveCall, encodeTransferCall, encodeCreateCallV2, encodeCreateCallV3, encodeCreateCallV4, PortalQuery, parseOkb, formatOkb, lpFeeProfileToV3Fee, } from './portal-ops.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 import { PROFIT_CONFIG, ZERO_ADDRESS } from '../utils/constants.js';
 import { DexQuery } from './dex.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 {
@@ -1569,9 +1571,11 @@ export class BundleExecutor {
         });
         totalCurveBuyWei = curveBuyData.reduce((sum, d) => sum + d.buyWei, 0n);
         // ✅ 并行构建和签名所有内盘买入 UserOps
+        // ✅ 使用 encodeBuyCallV3（支持 extensionData），与 V4 代币创建保持一致
+        const extensionData = params.extensionData ?? '0x';
         const signedCurveBuyOps = await mapWithConcurrency(curveBuyData, 5, async (data) => {
             const { wallet, info, buyWei, gasLimit } = data;
-            const buyData = encodeBuyCall(tokenAddress, buyWei, 0n);
+            const buyData = encodeBuyCallV3(tokenAddress, buyWei, 0n, extensionData);
             const buyCallData = encodeExecute(FLAP_PORTAL, buyWei, buyData);
             const buyOpRes = await aaManager.buildUserOpWithFixedGas({
                 ownerWallet: wallet,
@@ -1586,17 +1590,48 @@ export class BundleExecutor {
             return signedBuyOp.userOp;
         });
         ops1.push(...signedCurveBuyOps);
+        // === 向内盘买家 AA 账户转入 OKB（prefund + 买入金额）===
+        // ✅ 修复 AA21 didn't pay prefund 错误
+        const feeData = await provider.getFeeData();
+        const gasPrice = feeData.gasPrice ?? 100000000n;
+        const chainId = (await provider.getNetwork()).chainId;
+        let currentNonce = params.payerStartNonce ?? (await provider.getTransactionCount(payerWallet.address, 'pending'));
+        const DEFAULT_PREFUND_ESTIMATE = parseOkb('0.002'); // 预估每个 UserOp 的 prefund
+        const BUFFER_WEI = parseOkb('0.0005'); // 缓冲金额
+        for (let i = 0; i < curveBuyerWallets.length; i++) {
+            const buyerSender = curveBuyerInfos[i].sender;
+            const buyWei = curveBuyData[i].buyWei;
+            // 计算需要转入的金额：买入金额 + prefund + 缓冲
+            const requiredAmount = buyWei + DEFAULT_PREFUND_ESTIMATE + BUFFER_WEI;
+            // 检查买家 AA 账户当前余额
+            const currentBalance = await provider.getBalance(buyerSender);
+            if (currentBalance < requiredAmount) {
+                const transferAmount = requiredAmount - currentBalance;
+                console.log(`[内盘买家${i + 1}] 向 AA 账户 ${buyerSender} 转入 ${formatOkb(transferAmount)} OKB`);
+                const fundTxRequest = {
+                    to: buyerSender,
+                    value: transferAmount,
+                    nonce: currentNonce,
+                    gasLimit: 21000n,
+                    gasPrice,
+                    chainId
+                };
+                const signedFundTx = await payerWallet.signTransaction(fundTxRequest);
+                signedTransactions.push(signedFundTx);
+                currentNonce++;
+            }
+        }
         // 签名第一个 handleOps
-        const startNonce = params.payerStartNonce ?? (await provider.getTransactionCount(payerWallet.address, 'pending'));
         const signedMainTx = await this.signHandleOpsTx({
             ops: ops1,
             payerWallet: payerWallet,
             beneficiary: params.beneficiary ?? payerWallet.address,
-            nonce: startNonce,
+            nonce: currentNonce,
             gasLimit: effConfig.gasLimit,
             gasPrice: effConfig.minGasPriceGwei ? ethers.parseUnits(effConfig.minGasPriceGwei.toString(), 'gwei') : undefined
         });
         signedTransactions.push(signedMainTx);
+        currentNonce++;
         // --- 4. 构建外盘买入 handleOps (如果启用) ---
         if (enableDexBuy && dexBuyerPrivateKeys.length > 0) {
             const dexBuyerWallets = dexBuyerPrivateKeys.map(pk => createWallet(pk, config));
@@ -1614,10 +1649,34 @@ export class BundleExecutor {
                 return { wallet, info: dexBuyerInfos[i], buyWei };
             });
             totalDexBuyWei = dexBuyData.reduce((sum, d) => sum + d.buyWei, 0n);
+            // === 向外盘买家 AA 账户转入 OKB（prefund + 买入金额）===
+            for (let i = 0; i < dexBuyerWallets.length; i++) {
+                const buyerSender = dexBuyerInfos[i].sender;
+                const buyWei = dexBuyData[i].buyWei;
+                // 计算需要转入的金额：买入金额 + prefund + 缓冲
+                const requiredAmount = buyWei + DEFAULT_PREFUND_ESTIMATE + BUFFER_WEI;
+                // 检查买家 AA 账户当前余额
+                const dexBuyerBalance = await provider.getBalance(buyerSender);
+                if (dexBuyerBalance < requiredAmount) {
+                    const transferAmount = requiredAmount - dexBuyerBalance;
+                    console.log(`[外盘买家${i + 1}] 向 AA 账户 ${buyerSender} 转入 ${formatOkb(transferAmount)} OKB`);
+                    const fundTxRequest = {
+                        to: buyerSender,
+                        value: transferAmount,
+                        nonce: currentNonce,
+                        gasLimit: 21000n,
+                        gasPrice,
+                        chainId
+                    };
+                    const signedFundTx = await payerWallet.signTransaction(fundTxRequest);
+                    signedTransactions.push(signedFundTx);
+                    currentNonce++;
+                }
+            }
             // ✅ 并行构建和签名所有外盘买入 UserOps
             const signedDexBuyOps = await mapWithConcurrency(dexBuyData, 5, async (data) => {
                 const { wallet, info, buyWei } = data;
-                // ✅ 外盘买入：使用 Portal 的 swapExactInput 进行自动路由
+                // ✅ 外盘买入：使用 DEX Router 进行交换
                 let swapData;
                 let routerAddress;
                 if (dexType === 'V3') {
@@ -1655,11 +1714,12 @@ export class BundleExecutor {
                 ops: ops2,
                 payerWallet: payerWallet,
                 beneficiary: params.beneficiary ?? payerWallet.address,
-                nonce: startNonce + 1,
+                nonce: currentNonce,
                 gasLimit: effConfig.gasLimit,
                 gasPrice: effConfig.minGasPriceGwei ? ethers.parseUnits(effConfig.minGasPriceGwei.toString(), 'gwei') : undefined
             });
             signedTransactions.push(signedDexTx);
+            currentNonce++;
         }
         // --- 5. 利润提取 (Direct EOA transfer) ---
         let totalProfitWei = 0n;
@@ -1669,12 +1729,11 @@ export class BundleExecutor {
                 totalProfitWei += calculateProfitWei(totalDexBuyWei, profitSettings.profitBps);
             }
             if (totalProfitWei > 0n) {
-                const profitTxNonce = startNonce + (enableDexBuy ? 2 : 1);
                 const signedProfitTx = await this.signProfitTransaction({
                     payerWallet,
                     profitWei: totalProfitWei,
                     recipient: profitSettings.profitRecipient,
-                    nonce: profitTxNonce
+                    nonce: currentNonce
                 });
                 signedTransactions.push(signedProfitTx);
             }

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.96",
+  "version": "1.5.99",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",