four-flap-meme-sdk 1.6.64 → 1.6.66

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

@@ -17,7 +17,7 @@ import { createAAAccountManager, encodeExecute, createWallet } from './aa-accoun
 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';
+import { FLAP_PORTAL, WOKB, XLAYER_CHAIN_ID, DEFAULT_RPC_URL, ENTRYPOINT_V06, SIMPLE_ACCOUNT_FACTORY, PARTICLE_BUNDLER_URL, POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, } from './constants.js';
 import { PROFIT_CONFIG } from '../utils/constants.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 // ============================================================================
@@ -73,11 +73,20 @@ export async function buildBundleBuyOps(params) {
     const wokb = params.wrappedOkbAddress || WOKB;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
-    const routerAddress = params.routerAddress || '';
-    // 参数校验
-    if ((poolType === 'v2' || poolType === 'v3') && !routerAddress) {
-        throw new Error(`[buildBundleBuyOps] poolType=${poolType} 时必须提供 routerAddress`);
+    // ✅ V2/V3 模式使用默认 Router 地址（与 bundle.ts 保持一致）
+    let routerAddress = params.routerAddress || '';
+    if (poolType === 'v3') {
+        if (!routerAddress || routerAddress.toLowerCase() !== POTATOSWAP_V3_ROUTER.toLowerCase()) {
+            if (routerAddress && routerAddress !== POTATOSWAP_V3_ROUTER) {
+                console.warn(`[buildBundleBuyOps] V3 Router 校正: 前端传入 ${routerAddress} → 使用正确的 ${POTATOSWAP_V3_ROUTER}`);
+            }
+            routerAddress = POTATOSWAP_V3_ROUTER;
+        }
+    }
+    else if (poolType === 'v2' && !routerAddress) {
+        routerAddress = POTATOSWAP_V2_ROUTER;
     }
+    // 参数校验
     if (params.ownerPrivateKeys.length !== params.buyAmountsOkb.length) {
         throw new Error('[buildBundleBuyOps] 私钥数量与买入金额数量不一致');
     }
@@ -240,11 +249,20 @@ export async function buildBundleSellOps(params) {
     const wokb = params.wrappedOkbAddress || WOKB;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
-    const routerAddress = params.routerAddress || '';
     const tokenDecimals = params.tokenDecimals ?? 18;
     const nonceOffsetMap = params.nonceOffsetMap ?? new Map();
-    if ((poolType === 'v2' || poolType === 'v3') && !routerAddress) {
-        throw new Error(`[buildBundleSellOps] poolType=${poolType} 时必须提供 routerAddress`);
+    // ✅ V2/V3 模式使用默认 Router 地址（与 bundle.ts 保持一致）
+    let routerAddress = params.routerAddress || '';
+    if (poolType === 'v3') {
+        if (!routerAddress || routerAddress.toLowerCase() !== POTATOSWAP_V3_ROUTER.toLowerCase()) {
+            if (routerAddress && routerAddress !== POTATOSWAP_V3_ROUTER) {
+                console.warn(`[buildBundleSellOps] V3 Router 校正: 前端传入 ${routerAddress} → 使用正确的 ${POTATOSWAP_V3_ROUTER}`);
+            }
+            routerAddress = POTATOSWAP_V3_ROUTER;
+        }
+    }
+    else if (poolType === 'v2' && !routerAddress) {
+        routerAddress = POTATOSWAP_V2_ROUTER;
     }
     if (params.ownerPrivateKeys.length !== params.sellAmounts.length) {
         throw new Error('[buildBundleSellOps] 私钥数量与卖出金额数量不一致');

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

@@ -13,8 +13,7 @@ const DEX_BUY_CALL_GAS_LIMIT = 650000n; // DEX V3 买入操作
 const PREFUND_BUFFER_PERCENT = 200n; // prefund buffer 百分比 (200 = 2.0x)
 import { AAAccountManager, encodeExecute, encodeExecuteBatch, encodeExecuteViaMulticall3 } from './aa-account.js';
 import { encodeApproveCall, lpFeeProfileToV3Fee, } from './portal-ops.js';
-import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, encodeSwapExactTokensForTokensSupportingFee, encodeSwapExactOutputForTokensV3, // ✅ 新增：精确输出买入（V3 exactOutput）
- } from './dex.js';
+import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, encodeSwapExactTokensForTokensSupportingFee, } from './dex.js';
 import { BundleExecutor } from './bundle.js';
 import { PROFIT_CONFIG, ZERO_ADDRESS } from '../utils/constants.js';
 const multicallIface = new ethers.Interface([
@@ -204,9 +203,10 @@ export class AADexSwapExecutor {
         initIfNeeded(buyerSender, !!buyerAi?.deployed, buyerOwner.address);
         const decimals = await this.bundleExecutor['getErc20Decimals'](tokenAddress);
         const sellerTokenBal = await this.aaManager.getErc20Balance(tokenAddress, sellerSender);
+        // ✅ 当 sellPercent = 100 时直接使用完整余额，避免精度损失
         const sellAmountWei = sellAmount
             ? ethers.parseUnits(String(sellAmount), decimals)
-            : (sellerTokenBal * BigInt(sellPercent)) / 100n;
+            : (sellPercent >= 100 ? sellerTokenBal : (sellerTokenBal * BigInt(sellPercent)) / 100n);
         if (sellAmountWei <= 0n)
             throw new Error('卖出数量无效');
         // 授权检查
@@ -472,9 +472,10 @@ export class AADexSwapExecutor {
         }
         const decimals = await this.bundleExecutor['getErc20Decimals'](tokenAddress);
         const sellerTokenBal = await this.aaManager.getErc20Balance(tokenAddress, sellerAi.sender);
+        // ✅ 当 sellPercent = 100 时直接使用完整余额，避免精度损失
         const sellAmountWei = sellAmount
             ? ethers.parseUnits(String(sellAmount), decimals)
-            : (sellerTokenBal * BigInt(sellPercent)) / 100n;
+            : (sellPercent >= 100 ? sellerTokenBal : (sellerTokenBal * BigInt(sellPercent)) / 100n);
         let needApprove = false;
         if (!skipApprovalCheck) {
             const allowance = await this.aaManager.getErc20Allowance(tokenAddress, sellerAi.sender, effectiveRouter);
@@ -585,19 +586,32 @@ export class AADexSwapExecutor {
         const totalBuyerPrefundWithBuffer = (useNativeToken && capitalMode)
             ? buyerAis.reduce((sum, ai) => sum + estimateBuyerPrefundWithBuffer(ai.deployed), 0n)
             : 0n;
-        // ✅ 计算利润（不再压缩到“卖出-买入-prefund”上限，按配置直接刮取）
-        const profitWei = extractProfit ? calculateProfitWei(quotedSellOutWei, profitBps) : 0n;
-        // 资金充足性提示：不再阻断，记录警告后继续分发
+        // ✅ 计算利润（不再压缩到"卖出-买入-prefund"上限，按配置直接刮取）
+        let profitWei = extractProfit ? calculateProfitWei(quotedSellOutWei, profitBps) : 0n;
+        // ✅ 关键修复：如果分发总额 > 预估卖出所得，按比例缩减分发金额
+        // 这样可以避免 seller 需要用自己的 OKB 补贴分发
         const totalDistributeNeeded = totalBuyWei + totalBuyerPrefundWithBuffer + profitWei;
+        let adjustedBuyAmountsWei = buyAmountsWei;
+        let adjustedProfitWei = profitWei;
         if (quotedSellOutWei > 0n && totalDistributeNeeded > quotedSellOutWei) {
-            console.warn('[AA DEX 批量换手] ⚠️ 预估卖出金额不足，仍继续分发:', {
+            // 计算缩减比例，留 5% 安全边际给 seller 的 prefund
+            const safeQuoted = (quotedSellOutWei * 95n) / 100n; // 留 5% 给 seller prefund
+            const scaleRatio = safeQuoted > 0n ? (safeQuoted * 10000n) / totalDistributeNeeded : 0n;
+            // 按比例缩减 buyAmounts
+            adjustedBuyAmountsWei = buyAmountsWei.map(w => (w * scaleRatio) / 10000n);
+            const adjustedTotalBuyWei = adjustedBuyAmountsWei.reduce((a, b) => a + b, 0n);
+            // 按比例缩减 profit
+            adjustedProfitWei = (profitWei * scaleRatio) / 10000n;
+            console.warn('[AA DEX 批量换手] ⚠️ 分发金额超过预估卖出，已按比例缩减:', {
                 quotedSellOutWei: ethers.formatEther(quotedSellOutWei),
-                totalBuyWei: ethers.formatEther(totalBuyWei),
-                totalBuyerPrefund: ethers.formatEther(totalBuyerPrefundWithBuffer),
-                profitWei: ethers.formatEther(profitWei),
-                totalNeeded: ethers.formatEther(totalDistributeNeeded),
-                shortfall: ethers.formatEther(totalDistributeNeeded - quotedSellOutWei),
+                originalTotalBuyWei: ethers.formatEther(totalBuyWei),
+                adjustedTotalBuyWei: ethers.formatEther(adjustedTotalBuyWei),
+                originalProfitWei: ethers.formatEther(profitWei),
+                adjustedProfitWei: ethers.formatEther(adjustedProfitWei),
+                scaleRatio: `${Number(scaleRatio) / 100}%`,
             });
+            // 更新变量
+            profitWei = adjustedProfitWei;
         }
         // ✅ 利润在分发阶段通过 AA 内部刮取
         // ✅ 资金分发逻辑（仅 capitalMode=true 时执行，对应 BSC flapQuickBatchSwapMerkle）
@@ -684,7 +698,7 @@ export class AADexSwapExecutor {
                 // - 原生代币模式：分发金额 = 买入金额 + 买方 prefund
                 // - ERC20 模式：只分发 ERC20 代币，prefund 需要 buyer 自己有 OKB
                 const items = buyerSenders.map((to, i) => {
-                    const buyAmount = buyAmountsWei[i] ?? 0n;
+                    const buyAmount = adjustedBuyAmountsWei[i] ?? 0n;
                     const prefund = buyerPrefunds[i] ?? 0n;
                     return {
                         to,
@@ -856,7 +870,7 @@ export class AADexSwapExecutor {
                     const chainHops = allGeneratedHopWallets[buyerIdx];
                     const buyerSender = buyerSenders[buyerIdx];
                     const buyerAi = buyerAis[buyerIdx];
-                    const buyAmount = buyAmountsWei[buyerIdx] ?? 0n;
+                    const buyAmount = adjustedBuyAmountsWei[buyerIdx] ?? 0n;
                     if (buyAmount <= 0n)
                         continue;
                     // ✅ 计算 buyer 的 prefund（用于买入，使用常量）
@@ -997,66 +1011,36 @@ 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 稳定币
+        // ⚠️ 使用 exactInput 模式：用分发到的 OKB 尽可能多地买代币
+        // 不使用 exactOutput，因为卖出后价格下跌，可能导致 OKB 不够买回目标数量
         for (let i = 0; i < buyerOwners.length; i++) {
             const ai = buyerAis[i];
-            const buyWei = buyAmountsWei[i]; // 分发给买家的 OKB 金额（作为 amountInMaximum）
-            const targetTokenOut = targetTokenAmounts[i]; // 目标买入的代币数量
+            const buyWei = adjustedBuyAmountsWei[i]; // 分发给买家的 OKB 金额（已按比例调整）
             let buyCallData;
             if (useNativeToken) {
                 // ✅ 原生代币模式：OKB → Token
+                // ⚠️ 重要：使用 exactInput 而不是 exactOutput！
+                // 原因：卖出后价格下跌，exactOutput 需要更多 OKB 买回相同数量代币
+                //       如果 OKB 不够，exactOutput 会 revert，导致买入失败
+                // 解决方案：使用 exactInput，让买家用分到的 OKB 尽可能多地买代币
                 let buySwapData;
                 if (isV3Trade) {
-                    // ✅ 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,
-                        });
-                    }
+                    // V3 模式：使用 exactInput（固定 OKB 买尽可能多的代币）
+                    buySwapData = encodeSwapExactETHForTokensV3({
+                        tokenIn: WOKB,
+                        tokenOut: tokenAddress,
+                        fee: lpFeeProfileToV3Fee(lpFeeProfile),
+                        recipient: ai.sender,
+                        deadline,
+                        amountIn: buyWei,
+                        amountOutMinimum: 0n, // 不设最小输出，确保交易成功
+                        sqrtPriceLimitX96: 0n,
+                    });
+                    console.log(`[AA DEX V3 exactInput] Buyer ${i}: 花费 ${ethers.formatEther(buyWei)} OKB 买入代币`);
                 }
                 else {
-                    // V2 模式：不支持 exactOutput，使用 exactInput
+                    // V2 模式：使用 exactInput
                     buySwapData = encodeSwapExactETHForTokensSupportingFee(0n, [WOKB, tokenAddress], ai.sender, deadline);
                 }
                 buyCallData = encodeExecute(effectiveRouter, buyWei, buySwapData);

package/dist/xlayer/wash-ops.js

@@ -16,7 +16,7 @@ import { ethers } from 'ethers';
 import { createAAAccountManager, encodeExecute, createWallet } from './aa-account.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 { FLAP_PORTAL, WOKB, XLAYER_CHAIN_ID, DEFAULT_RPC_URL, ENTRYPOINT_V06, SIMPLE_ACCOUNT_FACTORY, PARTICLE_BUNDLER_URL, POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, } from './constants.js';
 import { PROFIT_CONFIG } from '../utils/constants.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 // ============================================================================
@@ -79,14 +79,26 @@ export async function buildWashOps(params) {
     const wokb = params.wrappedOkbAddress || WOKB;
     const deadline = Math.floor(Date.now() / 1000) + 60 * Math.max(1, Number(params.deadlineMinutes ?? 20));
     const portal = FLAP_PORTAL;
-    const routerAddress = params.routerAddress || '';
-    // 参数校验
-    if (poolType === 'v2' && !routerAddress) {
-        throw new Error('[buildWashOps] poolType=v2 时必须提供 routerAddress');
+    // ✅ V2/V3 模式使用默认 Router 地址（与 bundle.ts 保持一致）
+    // 避免前端传入错误地址导致交易失败
+    let routerAddress = params.routerAddress || '';
+    if (poolType === 'v3') {
+        // V3 模式：强制使用正确的 PotatoSwap V3 Router
+        if (!routerAddress || routerAddress.toLowerCase() !== POTATOSWAP_V3_ROUTER.toLowerCase()) {
+            if (routerAddress && routerAddress !== POTATOSWAP_V3_ROUTER) {
+                console.warn(`[buildWashOps] V3 Router 校正: 前端传入 ${routerAddress} → 使用正确的 ${POTATOSWAP_V3_ROUTER}`);
+            }
+            routerAddress = POTATOSWAP_V3_ROUTER;
+        }
     }
-    if (poolType === 'v3' && !routerAddress) {
-        throw new Error('[buildWashOps] poolType=v3 时必须提供 routerAddress');
+    else if (poolType === 'v2') {
+        // V2 模式：使用默认 PotatoSwap V2 Router（如果未提供）
+        if (!routerAddress) {
+            routerAddress = POTATOSWAP_V2_ROUTER;
+            console.log(`[buildWashOps] V2 Router 使用默认值: ${routerAddress}`);
+        }
     }
+    // 参数校验
     if (params.ownerPrivateKeys.length !== params.buyAmountsOkb.length) {
         throw new Error('[buildWashOps] 私钥数量与买入金额数量不一致');
     }

package/package.json

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