four-flap-meme-sdk 1.6.60 → 1.6.63

package/dist/xlayer/aa-account.js

@@ -503,8 +503,16 @@ export class AAAccountManager {
      */
     async buildUserOpWithFixedGas(params) {
         await this.syncEntryPointIfNeeded();
-        const feeData = await this.getFeeData();
-        const legacyGasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? DEFAULT_GAS_PRICE;
+        // ✅ 关键修复：优先使用传入的 fixedGas.gasPrice，确保整个流程使用一致的 gasPrice
+        // 这样可以避免 feeData 缓存过期导致的 gasPrice 不一致问题
+        let legacyGasPrice;
+        if (params.fixedGas?.gasPrice !== undefined) {
+            legacyGasPrice = params.fixedGas.gasPrice;
+        }
+        else {
+            const feeData = await this.getFeeData();
+            legacyGasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? DEFAULT_GAS_PRICE;
+        }
         const paymasterAndData = this.buildPaymasterAndData();
         const callGasLimit = params.fixedGas?.callGasLimit ?? DEFAULT_CALL_GAS_LIMIT_SELL;
         const verificationGasLimit = params.deployed

package/dist/xlayer/bundle-buy-first.js

@@ -14,7 +14,7 @@
  */
 import { ethers } from 'ethers';
 import { createAAAccountManager, encodeExecute, createWallet } from './aa-account.js';
-import { encodeBuyCall, encodeSellCall } from './portal-ops.js';
+import { encodeBuyCall, encodeSellCall, PortalQuery, lpFeeProfileToV3Fee } from './portal-ops.js';
 import { encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, } from './dex.js';
 import { encodeApproveCall } from './portal-ops.js';
 import { FLAP_PORTAL, WOKB, XLAYER_CHAIN_ID, DEFAULT_RPC_URL, ENTRYPOINT_V06, SIMPLE_ACCOUNT_FACTORY, PARTICLE_BUNDLER_URL, } from './constants.js';
@@ -71,7 +71,6 @@ function normalizeConfig(cfg) {
 export async function buildBundleBuyOps(params) {
     const poolType = params.poolType || 'flap';
     const wokb = params.wrappedOkbAddress || WOKB;
-    const v3Fee = params.v3Fee || 2500;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
     const routerAddress = params.routerAddress || '';
@@ -85,6 +84,22 @@ export async function buildBundleBuyOps(params) {
     // ✅ 归一化配置，填充默认值（与前端 normalizeXLayerAAConfig 保持一致）
     const config = normalizeConfig(params.config);
     const aaManager = createAAAccountManager(config);
+    // ✅ V3 模式：直接从链上读取 lpFeeProfile 获取正确的 fee（与 bundleGraduateBuy 保持一致）
+    let v3Fee = params.v3Fee || 2500;
+    if (poolType === 'v3') {
+        try {
+            const portalQuery = new PortalQuery({ rpcUrl: config.rpcUrl, chainId: config.chainId });
+            const tokenState = await portalQuery.getTokenV7(params.tokenAddress);
+            const correctV3Fee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+            if (correctV3Fee !== v3Fee) {
+                console.log(`[buildBundleBuyOps] V3 Fee 校正: 前端传入 ${v3Fee}, 链上 lpFeeProfile=${tokenState.lpFeeProfile} → 正确 fee=${correctV3Fee}`);
+            }
+            v3Fee = correctV3Fee;
+        }
+        catch (e) {
+            console.warn(`[buildBundleBuyOps] 读取 lpFeeProfile 失败，使用前端传入的 v3Fee=${v3Fee}:`, e);
+        }
+    }
     const ownerWallets = params.ownerPrivateKeys.map(pk => createWallet(pk, config));
     const owners = ownerWallets.map(w => w.address);
     const accounts = await aaManager.getMultipleAccountInfo(owners);
@@ -223,7 +238,6 @@ export async function buildBundleBuyOps(params) {
 export async function buildBundleSellOps(params) {
     const poolType = params.poolType || 'flap';
     const wokb = params.wrappedOkbAddress || WOKB;
-    const v3Fee = params.v3Fee || 2500;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
     const routerAddress = params.routerAddress || '';
@@ -238,6 +252,22 @@ export async function buildBundleSellOps(params) {
     // ✅ 归一化配置，填充默认值（与前端 normalizeXLayerAAConfig 保持一致）
     const config = normalizeConfig(params.config);
     const aaManager = createAAAccountManager(config);
+    // ✅ V3 模式：直接从链上读取 lpFeeProfile 获取正确的 fee（与 bundleGraduateBuy 保持一致）
+    let v3Fee = params.v3Fee || 2500;
+    if (poolType === 'v3') {
+        try {
+            const portalQuery = new PortalQuery({ rpcUrl: config.rpcUrl, chainId: config.chainId });
+            const tokenState = await portalQuery.getTokenV7(params.tokenAddress);
+            const correctV3Fee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+            if (correctV3Fee !== v3Fee) {
+                console.log(`[buildBundleSellOps] V3 Fee 校正: 前端传入 ${v3Fee}, 链上 lpFeeProfile=${tokenState.lpFeeProfile} → 正确 fee=${correctV3Fee}`);
+            }
+            v3Fee = correctV3Fee;
+        }
+        catch (e) {
+            console.warn(`[buildBundleSellOps] 读取 lpFeeProfile 失败，使用前端传入的 v3Fee=${v3Fee}:`, e);
+        }
+    }
     const ownerWallets = params.ownerPrivateKeys.map(pk => createWallet(pk, config));
     const owners = ownerWallets.map(w => w.address);
     const accounts = await aaManager.getMultipleAccountInfo(owners);

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

@@ -7,12 +7,13 @@ import { POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, POTATOSWAP_V3_FACTORY, WOKB
 // 多跳 prefund 估算用的 gas 常量（可配置）
 const HOP_CALL_GAS_LIMIT = 150000n; // hop 转账操作
 const DEX_BUY_CALL_GAS_LIMIT = 650000n; // DEX V3 买入操作
-// ✅ 增加余额检查 buffer 从 120% 到 180%，确保 gasPrice 波动时也有足够余额
-// 预充值使用 200% buffer，这里使用 180% 作为安全阈值
-const PREFUND_BUFFER_PERCENT = 180n; // prefund buffer 百分比 (180 = 1.8x)
+// ✅ 增加余额检查 buffer 从 180% 到 250%，确保 gasPrice 波动时也有足够余额
+// 预充值使用 200% buffer，这里使用 250% 作为安全阈值（覆盖更大的 gasPrice 波动）
+const PREFUND_BUFFER_PERCENT = 250n; // prefund buffer 百分比 (250 = 2.5x)
 import { AAAccountManager, encodeExecute, encodeExecuteBatch, encodeExecuteViaMulticall3 } from './aa-account.js';
 import { encodeApproveCall, lpFeeProfileToV3Fee, } from './portal-ops.js';
-import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, encodeSwapExactTokensForTokensSupportingFee, } from './dex.js';
+import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, encodeSwapExactTokensForTokensSupportingFee, encodeSwapExactOutputForTokensV3, // ✅ 新增：精确输出买入（V3 exactOutput）
+ } from './dex.js';
 import { BundleExecutor } from './bundle.js';
 import { PROFIT_CONFIG, ZERO_ADDRESS } from '../utils/constants.js';
 const multicallIface = new ethers.Interface([
@@ -478,6 +479,10 @@ export class AADexSwapExecutor {
             const allowance = await this.aaManager.getErc20Allowance(tokenAddress, sellerAi.sender, effectiveRouter);
             needApprove = allowance < sellAmountWei;
         }
+        // ✅ 关键修复：在构建 UserOps 之前获取 feeData，整个方法使用同一个 gasPrice
+        // 这样可以避免 feeData 缓存过期导致的不一致问题
+        const fixedFeeData = await this.aaManager.getFeeData();
+        const fixedGasPrice = fixedFeeData.gasPrice ?? fixedFeeData.maxFeePerGas ?? 5000000000n;
         const outOps = [];
         if (needApprove) {
             const { userOp } = await this.aaManager.buildUserOpWithFixedGas({
@@ -487,6 +492,7 @@ export class AADexSwapExecutor {
                 initCode: consumeInitCode(sellerAi.sender),
                 callData: encodeExecute(tokenAddress, 0n, encodeApproveCall(effectiveRouter)),
                 deployed: sellerAi.deployed,
+                fixedGas: { gasPrice: fixedGasPrice }, // ✅ 使用统一的 gasPrice
             });
             const signedApprove = await this.aaManager.signUserOp(userOp, sellerOwner);
             outOps.push(signedApprove.userOp);
@@ -557,31 +563,36 @@ export class AADexSwapExecutor {
                 return 0n;
             }
         })();
-        // ✅ 关键修复：提前计算 buyerPrefund，用于资金充足性检查
-        // 在 capitalMode 下，分发金额 = 买入金额 + buyerPrefund + 利润
-        // 必须确保卖出所得 >= 分发金额，否则交易会失败
-        const feeDataEarly = await this.aaManager.getFeeData();
-        const gasPriceEarly = feeDataEarly.gasPrice ?? feeDataEarly.maxFeePerGas ?? 5000000000n;
-        const estimateBuyerPrefundEarly = (deployed) => {
+        // ✅ 估算 prefund 的函数（整个方法统一使用）
+        // 注意：分发金额使用带 buffer 的 prefund，确保 buyer 有足够余额
+        const estimateBuyerPrefundWithBuffer = (deployed) => {
             const callGas = DEX_BUY_CALL_GAS_LIMIT;
             const verifyGas = deployed ? VERIFICATION_GAS_LIMIT_NORMAL : VERIFICATION_GAS_LIMIT_DEPLOY;
             const preVerifyGas = PRE_VERIFICATION_GAS;
             const totalGas = callGas + verifyGas + preVerifyGas;
-            return (totalGas * gasPriceEarly * PREFUND_BUFFER_PERCENT) / 100n;
+            return (totalGas * fixedGasPrice * PREFUND_BUFFER_PERCENT) / 100n;
+        };
+        // ✅ 估算实际 prefund（不带 buffer，用于 UserOp 构建时的计算）
+        const estimateActualPrefund = (deployed) => {
+            const callGas = DEX_BUY_CALL_GAS_LIMIT;
+            const verifyGas = deployed ? VERIFICATION_GAS_LIMIT_NORMAL : VERIFICATION_GAS_LIMIT_DEPLOY;
+            const preVerifyGas = PRE_VERIFICATION_GAS;
+            const totalGas = callGas + verifyGas + preVerifyGas;
+            return totalGas * fixedGasPrice;
         };
         // ✅ 计算所有 buyer 需要的 prefund 总和（仅原生代币模式 + capitalMode 需要）
-        const totalBuyerPrefundEarly = (useNativeToken && capitalMode)
-            ? buyerAis.reduce((sum, ai) => sum + estimateBuyerPrefundEarly(ai.deployed), 0n)
+        const totalBuyerPrefundWithBuffer = (useNativeToken && capitalMode)
+            ? buyerAis.reduce((sum, ai) => sum + estimateBuyerPrefundWithBuffer(ai.deployed), 0n)
             : 0n;
         // ✅ 计算利润（不再压缩到“卖出-买入-prefund”上限，按配置直接刮取）
         const profitWei = extractProfit ? calculateProfitWei(quotedSellOutWei, profitBps) : 0n;
         // 资金充足性提示：不再阻断，记录警告后继续分发
-        const totalDistributeNeeded = totalBuyWei + totalBuyerPrefundEarly + profitWei;
+        const totalDistributeNeeded = totalBuyWei + totalBuyerPrefundWithBuffer + profitWei;
         if (quotedSellOutWei > 0n && totalDistributeNeeded > quotedSellOutWei) {
             console.warn('[AA DEX 批量换手] ⚠️ 预估卖出金额不足，仍继续分发:', {
                 quotedSellOutWei: ethers.formatEther(quotedSellOutWei),
                 totalBuyWei: ethers.formatEther(totalBuyWei),
-                totalBuyerPrefund: ethers.formatEther(totalBuyerPrefundEarly),
+                totalBuyerPrefund: ethers.formatEther(totalBuyerPrefundWithBuffer),
                 profitWei: ethers.formatEther(profitWei),
                 totalNeeded: ethers.formatEther(totalDistributeNeeded),
                 shortfall: ethers.formatEther(totalDistributeNeeded - quotedSellOutWei),
@@ -636,23 +647,12 @@ export class AADexSwapExecutor {
         if (capitalMode && buyerSenders.length > 0 && totalBuyWei > 0n) {
             if (effectiveHopCount <= 0) {
                 console.log('[AA DEX 批量换手] 进入直接分发模式 (effectiveHopCount <= 0)');
-                // ✅ 关键修复：计算每个买方执行买入 UserOp 需要的 prefund（gas 费用）
-                // EntryPoint 在 validation 阶段会扣除 prefund，此时分发还没执行
-                // 因此需要为每个买方额外预留 prefund
-                const feeData = await this.aaManager.getFeeData();
-                const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 5000000000n; // 5 gwei fallback
-                const estimateBuyerPrefund = (deployed) => {
-                    // 买入操作的 gas（使用常量）
-                    const callGas = DEX_BUY_CALL_GAS_LIMIT;
-                    const verifyGas = deployed ? VERIFICATION_GAS_LIMIT_NORMAL : VERIFICATION_GAS_LIMIT_DEPLOY;
-                    const preVerifyGas = PRE_VERIFICATION_GAS;
-                    const totalGas = callGas + verifyGas + preVerifyGas;
-                    return (totalGas * gasPrice * PREFUND_BUFFER_PERCENT) / 100n;
-                };
-                // 计算每个买方需要的 prefund
-                const buyerPrefunds = buyerAis.map(ai => estimateBuyerPrefund(ai.deployed));
+                // ✅ 关键修复：使用开始时获取的 fixedGasPrice 计算 prefund
+                // 这样确保检查、分发和 UserOp 构建使用同一个 gasPrice，避免不一致
+                // 计算每个买方需要的 prefund（带 buffer，用于余额检查和分发）
+                const buyerPrefunds = buyerAis.map(ai => estimateBuyerPrefundWithBuffer(ai.deployed));
                 const totalBuyerPrefund = buyerPrefunds.reduce((a, b) => a + b, 0n);
-                console.log(`[AA DEX 直接分发] 买方数量: ${buyerSenders.length}, 总 prefund 预估: ${ethers.formatEther(totalBuyerPrefund)} OKB`);
+                console.log(`[AA DEX 直接分发] 买方数量: ${buyerSenders.length}, 总 prefund 预估: ${ethers.formatEther(totalBuyerPrefund)} OKB, fixedGasPrice: ${fixedGasPrice.toString()}`);
                 // ✅ 关键修复：检查 buyer 钱包是否有足够的 OKB 支付 prefund
                 // ERC-4337 handleOps 执行顺序：先验证所有 UserOps（需要 prefund），再执行所有 UserOps
                 // 在 Validation 阶段，Disperse UserOp 还没执行，所以 Buyer 还没收到资金
@@ -738,14 +738,13 @@ export class AADexSwapExecutor {
                     usePrefundedHops: hasPrefundedHops,
                     usePaymaster: hasPaymaster,
                 });
-                const feeData = await this.aaManager.getFeeData();
-                const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 5000000000n;
-                // 预估 prefund 的函数（使用全局常量）
+                // ✅ 使用开始时获取的 fixedGasPrice，确保整个方法一致性
+                // 预估 prefund 的函数（使用 fixedGasPrice）
                 const estimatePrefund = (callGas, deployed) => {
                     const verifyGas = deployed ? VERIFICATION_GAS_LIMIT_NORMAL : VERIFICATION_GAS_LIMIT_DEPLOY;
                     const preVerifyGas = PRE_VERIFICATION_GAS;
                     const totalGas = callGas + verifyGas + preVerifyGas;
-                    return (totalGas * gasPrice * PREFUND_BUFFER_PERCENT) / 100n;
+                    return (totalGas * fixedGasPrice * PREFUND_BUFFER_PERCENT) / 100n;
                 };
                 // ✅ 构建 hop 钱包列表
                 // 如果有预充值的 hop 钱包，使用它们；否则生成新钱包（需要 Paymaster）
@@ -931,6 +930,7 @@ export class AADexSwapExecutor {
                             deployed: currentHop.deployed,
                             fixedGas: {
                                 callGasLimit: HOP_CALL_GAS_LIMIT,
+                                gasPrice: fixedGasPrice, // ✅ 使用统一的 gasPrice
                             },
                         });
                         const signedHop = await this.aaManager.signUserOp(hopUserOp, currentHop.wallet);
@@ -957,6 +957,7 @@ export class AADexSwapExecutor {
                         deployed: lastHop.deployed,
                         fixedGas: {
                             callGasLimit: HOP_CALL_GAS_LIMIT,
+                            gasPrice: fixedGasPrice, // ✅ 使用统一的 gasPrice
                         },
                     });
                     const signedLastHop = await this.aaManager.signUserOp(lastHopUserOp, lastHop.wallet);
@@ -995,40 +996,80 @@ export class AADexSwapExecutor {
             });
             outOps.push(signedProfitTransfer.userOp);
         }
+        // ✅ 计算每个买家应该买入的代币数量（用于 V3 exactOutput 模式）
+        // 逻辑：卖出 sellAmountWei 个代币 → 买家按比例买回
+        // targetTokenAmounts[i] = sellAmountWei * (buyAmountsWei[i] / totalBuyWei)
+        // 
+        // exactOutput 模式优势：
+        // 1. 精确控制每个买家买入的代币数量
+        // 2. amountInMaximum 设为分发金额，确保不超支
+        // 3. 多余的 OKB 通过 refundETH 退回买家钱包
+        const targetTokenAmounts = capitalMode && totalBuyWei > 0n
+            ? buyAmountsWei.map(buyWei => (sellAmountWei * buyWei) / totalBuyWei)
+            : buyAmountsWei.map(() => 0n); // 非资金利用率模式不使用 exactOutput
+        console.log('[AA DEX 批量换手] 目标代币数量计算:', {
+            sellAmountWei: sellAmountWei.toString(),
+            totalBuyWei: ethers.formatEther(totalBuyWei),
+            targetTokenAmounts: targetTokenAmounts.map(a => a.toString()),
+            useExactOutput: capitalMode && isV3Trade && useNativeToken,
+        });
         // Batch Buy ops（分发后再执行）- ✅ 支持 V2/V3，支持 ERC20 稳定币
         for (let i = 0; i < buyerOwners.length; i++) {
             const ai = buyerAis[i];
-            const buyWei = buyAmountsWei[i];
+            const buyWei = buyAmountsWei[i]; // 分发给买家的 OKB 金额（作为 amountInMaximum）
+            const targetTokenOut = targetTokenAmounts[i]; // 目标买入的代币数量
             let buyCallData;
             if (useNativeToken) {
                 // ✅ 原生代币模式：OKB → Token
                 let buySwapData;
                 if (isV3Trade) {
-                    buySwapData = encodeSwapExactETHForTokensV3({
-                        tokenIn: WOKB,
-                        tokenOut: tokenAddress,
-                        fee: lpFeeProfileToV3Fee(lpFeeProfile),
-                        recipient: ai.sender,
-                        deadline,
-                        amountIn: buyWei,
-                        amountOutMinimum: 0n,
-                        sqrtPriceLimitX96: 0n,
-                    });
+                    // ✅ V3 资金利用率模式：使用 exactOutput 精确买入目标代币数量
+                    // - amountOut: 精确的代币数量（sellAmountWei 按比例分配）
+                    // - amountInMaximum: 最多花费的 OKB（分发给该买家的金额）
+                    // - refundETH: 多余的 OKB 自动退回
+                    if (capitalMode && targetTokenOut > 0n) {
+                        buySwapData = encodeSwapExactOutputForTokensV3({
+                            tokenIn: WOKB,
+                            tokenOut: tokenAddress,
+                            fee: lpFeeProfileToV3Fee(lpFeeProfile),
+                            recipient: ai.sender,
+                            deadline,
+                            amountOut: targetTokenOut, // ✅ 精确买入的代币数量
+                            amountInMaximum: buyWei, // ✅ 最多花费的 OKB（分发金额）
+                            sqrtPriceLimitX96: 0n,
+                        });
+                        console.log(`[AA DEX V3 exactOutput] Buyer ${i}: 目标代币 ${targetTokenOut.toString()}, 最大花费 ${ethers.formatEther(buyWei)} OKB`);
+                    }
+                    else {
+                        // 非资金利用率模式：使用 exactInput（固定 OKB 买尽可能多的代币）
+                        buySwapData = encodeSwapExactETHForTokensV3({
+                            tokenIn: WOKB,
+                            tokenOut: tokenAddress,
+                            fee: lpFeeProfileToV3Fee(lpFeeProfile),
+                            recipient: ai.sender,
+                            deadline,
+                            amountIn: buyWei,
+                            amountOutMinimum: 0n,
+                            sqrtPriceLimitX96: 0n,
+                        });
+                    }
                 }
                 else {
+                    // V2 模式：不支持 exactOutput，使用 exactInput
                     buySwapData = encodeSwapExactETHForTokensSupportingFee(0n, [WOKB, tokenAddress], ai.sender, deadline);
                 }
                 buyCallData = encodeExecute(effectiveRouter, buyWei, buySwapData);
             }
             else {
                 // ✅ ERC20 模式：quoteToken → Token（需要先 approve）
+                // 注意：ERC20 模式暂不支持 exactOutput，保持 exactInput
                 const approveData = encodeApproveCall(effectiveRouter, buyWei);
                 const swapData = encodeSwapExactTokensForTokensSupportingFee(buyWei, 0n, [quoteToken, tokenAddress], ai.sender, deadline);
                 buyCallData = encodeExecuteBatch([quoteToken, effectiveRouter], [0n, 0n], [approveData, swapData]);
             }
-            // ✅ 关键修复：使用 buildUserOpWithFixedGas，确保 callGasLimit 与预检查时一致
-            // 预检查使用 DEX_BUY_CALL_GAS_LIMIT (650,000)，这里也必须使用相同的值
-            // 否则 buildUserOpWithState 会动态估算，可能得到更高的值，导致 prefund 不足
+            // ✅ 关键修复：使用 buildUserOpWithFixedGas，确保 callGasLimit 和 gasPrice 与预检查时一致
+            // 预检查使用 DEX_BUY_CALL_GAS_LIMIT (650,000) 和 fixedGasPrice
+            // 这里必须使用相同的值，避免 gasPrice 不一致导致 prefund 不足
             const { userOp: buyUserOp } = await this.aaManager.buildUserOpWithFixedGas({
                 ownerWallet: buyerOwners[i],
                 sender: ai.sender,
@@ -1038,6 +1079,7 @@ export class AADexSwapExecutor {
                 deployed: ai.deployed,
                 fixedGas: {
                     callGasLimit: DEX_BUY_CALL_GAS_LIMIT,
+                    gasPrice: fixedGasPrice, // ✅ 使用统一的 gasPrice
                 },
             });
             const signedBuy = await this.aaManager.signUserOp(buyUserOp, buyerOwners[i]);

package/dist/xlayer/dex.d.ts

@@ -20,6 +20,20 @@ interface V3ExactInputSingleParams {
     amountOutMinimum: bigint;
     sqrtPriceLimitX96: bigint;
 }
+/**
+ * ✅ V3 exactOutputSingle 参数结构
+ * 精确输出模式：固定输出代币数量，输入金额可变（不超过 amountInMaximum）
+ */
+export interface V3ExactOutputSingleParams {
+    tokenIn: string;
+    tokenOut: string;
+    fee: number;
+    recipient: string;
+    deadline: number;
+    amountOut: bigint;
+    amountInMaximum: bigint;
+    sqrtPriceLimitX96: bigint;
+}
 /**
  * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
  */
@@ -33,7 +47,7 @@ export declare function encodeRefundETH(): string;
  */
 export declare function encodeV3Multicall(data: string[]): string;
 /**
- * ✅ 编码 V3 买入调用（OKB → Token）
+ * ✅ 编码 V3 买入调用（OKB → Token）- exactInput 模式
  *
  * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
  * - AA 的 execute 会正确传递 msg.value
@@ -42,6 +56,28 @@ export declare function encodeV3Multicall(data: string[]): string;
  * 对于 EOA 模式：调用者需要自己用 multicall 包装
  */
 export declare function encodeSwapExactETHForTokensV3(params: V3ExactInputSingleParams): string;
+/**
+ * ✅ 编码 V3 精确输出买入调用（OKB → Token）- exactOutput 模式
+ *
+ * 使用 multicall 包装 exactOutputSingle + refundETH：
+ * 1. exactOutputSingle: 用最多 amountInMaximum OKB 买入精确 amountOut 个代币
+ * 2. refundETH: 将未使用的 OKB 退回给调用者
+ *
+ * 优势：
+ * - 精确控制买入的代币数量
+ * - 多余的 OKB 自动退回，不会浪费
+ *
+ * 适用场景：
+ * - 资金利用率模式：卖出后需要精确买回固定数量的代币
+ * - 确保每个买家获得精确的代币数量
+ *
+ * @param params.amountOut - 要买入的精确代币数量
+ * @param params.amountInMaximum - 最多花费的 OKB 数量（通常设为分发金额）
+ * @param params.refundRecipient - 退款接收者（默认为 recipient）
+ */
+export declare function encodeSwapExactOutputForTokensV3(params: V3ExactOutputSingleParams & {
+    refundRecipient?: string;
+}): string;
 /**
  * ✅ 编码 V3 卖出调用（Token → OKB）
  * 使用 multicall 包装 exactInputSingle + unwrapWETH9

package/dist/xlayer/dex.js

@@ -23,6 +23,24 @@ const v3RouterIface = new Interface(POTATOSWAP_V3_ROUTER_ABI);
 function encodeExactInputSingle(params) {
     return v3RouterIface.encodeFunctionData('exactInputSingle', [params]);
 }
+/**
+ * ✅ 编码 exactOutputSingle 调用（精确输出模式）
+ *
+ * 使用场景：
+ * - 需要精确控制买入代币数量时
+ * - 资金利用率模式下，卖出后按比例买回精确数量的代币
+ *
+ * 优势：
+ * - 精确控制每个地址买到的代币数量
+ * - 避免因滑点导致买入数量不一致
+ *
+ * 注意：
+ * - 如果需要的 OKB > amountInMaximum，交易会失败
+ * - 多余的 OKB 需要通过 refundETH 退回
+ */
+function encodeExactOutputSingle(params) {
+    return v3RouterIface.encodeFunctionData('exactOutputSingle', [params]);
+}
 /**
  * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
  */
@@ -42,7 +60,7 @@ export function encodeV3Multicall(data) {
     return v3RouterIface.encodeFunctionData('multicall', [data]);
 }
 /**
- * ✅ 编码 V3 买入调用（OKB → Token）
+ * ✅ 编码 V3 买入调用（OKB → Token）- exactInput 模式
  *
  * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
  * - AA 的 execute 会正确传递 msg.value
@@ -55,6 +73,34 @@ export function encodeSwapExactETHForTokensV3(params) {
     // V3 Router 会自动处理原生币 → WOKB 的转换
     return encodeExactInputSingle(params);
 }
+/**
+ * ✅ 编码 V3 精确输出买入调用（OKB → Token）- exactOutput 模式
+ *
+ * 使用 multicall 包装 exactOutputSingle + refundETH：
+ * 1. exactOutputSingle: 用最多 amountInMaximum OKB 买入精确 amountOut 个代币
+ * 2. refundETH: 将未使用的 OKB 退回给调用者
+ *
+ * 优势：
+ * - 精确控制买入的代币数量
+ * - 多余的 OKB 自动退回，不会浪费
+ *
+ * 适用场景：
+ * - 资金利用率模式：卖出后需要精确买回固定数量的代币
+ * - 确保每个买家获得精确的代币数量
+ *
+ * @param params.amountOut - 要买入的精确代币数量
+ * @param params.amountInMaximum - 最多花费的 OKB 数量（通常设为分发金额）
+ * @param params.refundRecipient - 退款接收者（默认为 recipient）
+ */
+export function encodeSwapExactOutputForTokensV3(params) {
+    // 1. exactOutputSingle: 买入精确数量的代币
+    const swapData = encodeExactOutputSingle(params);
+    // 2. refundETH: 退还未使用的 OKB
+    // 注意：refundETH 会将多余的原生币退回给 msg.sender（AA 钱包）
+    const refundData = encodeRefundETH();
+    // 使用 multicall 打包两个调用
+    return encodeV3Multicall([swapData, refundData]);
+}
 /**
  * ✅ 编码 V3 卖出调用（Token → OKB）
  * 使用 multicall 包装 exactInputSingle + unwrapWETH9

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

@@ -7,9 +7,9 @@ import { FLAP_PORTAL, ZERO_ADDRESS, MULTICALL3, VERIFICATION_GAS_LIMIT_DEPLOY, V
 // 多跳 prefund 估算用的 gas 常量（可配置）
 const HOP_CALL_GAS_LIMIT = 150000n; // hop 转账操作
 const PORTAL_BUY_CALL_GAS_LIMIT = 450000n; // Portal 买入操作
-// ✅ 增加余额检查 buffer 从 120% 到 180%，确保 gasPrice 波动时也有足够余额
-// 预充值使用 200% buffer，这里使用 180% 作为安全阈值
-const PREFUND_BUFFER_PERCENT = 180n; // prefund buffer 百分比 (180 = 1.8x)
+// ✅ 增加余额检查 buffer 从 180% 到 250%，确保 gasPrice 波动时也有足够余额
+// 预充值使用 200% buffer，这里使用 250% 作为安全阈值（覆盖更大的 gasPrice 波动）
+const PREFUND_BUFFER_PERCENT = 250n; // prefund buffer 百分比 (250 = 2.5x)
 import { AAAccountManager, encodeExecute, encodeExecuteBatch, encodeExecuteViaMulticall3 } from './aa-account.js';
 import { encodeBuyCall, encodeSellCall, encodeBuyCallWithQuote, encodeSellCallWithQuote, encodeApproveCall, PortalQuery, parseOkb, } from './portal-ops.js';
 import { BundleExecutor } from './bundle.js';

package/dist/xlayer/types.d.ts

@@ -51,6 +51,8 @@ export interface FixedGasConfig {
     verificationGasLimitUndeployed?: bigint;
     /** preVerificationGas（默认用 SDK 常量） */
     preVerificationGas?: bigint;
+    /** ✅ 固定 gasPrice（若不提供，SDK 会调用 getFeeData 获取） */
+    gasPrice?: bigint;
 }
 /**
  * XLayer SDK 基础配置

package/dist/xlayer/wash-ops.js

@@ -14,7 +14,7 @@
  */
 import { ethers } from 'ethers';
 import { createAAAccountManager, encodeExecute, createWallet } from './aa-account.js';
-import { encodeBuyCall, encodeSellCall, PortalQuery } from './portal-ops.js';
+import { encodeBuyCall, encodeSellCall, PortalQuery, lpFeeProfileToV3Fee } from './portal-ops.js';
 import { encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, DexQuery, } from './dex.js';
 import { FLAP_PORTAL, WOKB, XLAYER_CHAIN_ID, DEFAULT_RPC_URL, ENTRYPOINT_V06, SIMPLE_ACCOUNT_FACTORY, PARTICLE_BUNDLER_URL, } from './constants.js';
 import { PROFIT_CONFIG } from '../utils/constants.js';
@@ -77,7 +77,6 @@ function normalizeConfig(cfg) {
 export async function buildWashOps(params) {
     const poolType = params.poolType || 'flap';
     const wokb = params.wrappedOkbAddress || WOKB;
-    const v3Fee = params.v3Fee || 2500;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
     const routerAddress = params.routerAddress || '';
@@ -88,15 +87,29 @@ export async function buildWashOps(params) {
     if (poolType === 'v3' && !routerAddress) {
         throw new Error('[buildWashOps] poolType=v3 时必须提供 routerAddress');
     }
-    if (poolType === 'v3' && !params.v3Fee) {
-        throw new Error('[buildWashOps] poolType=v3 时必须提供 v3Fee');
-    }
     if (params.ownerPrivateKeys.length !== params.buyAmountsOkb.length) {
         throw new Error('[buildWashOps] 私钥数量与买入金额数量不一致');
     }
     // ✅ 归一化配置，填充默认值（与前端 normalizeXLayerAAConfig 保持一致）
     const config = normalizeConfig(params.config);
     const aaManager = createAAAccountManager(config);
+    // ✅ V3 模式：直接从链上读取 lpFeeProfile 获取正确的 fee（与 bundleGraduateBuy 保持一致）
+    // 不再依赖前端传入的 v3Fee 参数，避免前端传入错误值导致交易失败
+    let v3Fee = params.v3Fee || 2500;
+    if (poolType === 'v3') {
+        try {
+            const portalQuery = new PortalQuery({ rpcUrl: config.rpcUrl, chainId: config.chainId });
+            const tokenState = await portalQuery.getTokenV7(params.tokenAddress);
+            const correctV3Fee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+            if (correctV3Fee !== v3Fee) {
+                console.log(`[buildWashOps] V3 Fee 校正: 前端传入 ${v3Fee}, 链上 lpFeeProfile=${tokenState.lpFeeProfile} → 正确 fee=${correctV3Fee}`);
+            }
+            v3Fee = correctV3Fee;
+        }
+        catch (e) {
+            console.warn(`[buildWashOps] 读取 lpFeeProfile 失败，使用前端传入的 v3Fee=${v3Fee}:`, e);
+        }
+    }
     // ✅ 预先过滤无效私钥并保持索引对应
     const validEntries = [];
     for (let i = 0; i < params.ownerPrivateKeys.length; i++) {

package/package.json

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