four-flap-meme-sdk 1.6.95 → 1.6.97

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

@@ -255,6 +255,8 @@ export declare function submitDirectToRpc(signedTransactions: string[], config:
  *
  * 每笔交易广播后会等待上链确认，确保后续交易能正确执行
  *
+ * ⚠️ 多跳场景：如果某笔交易失败，会立即停止（因为后续交易肯定也会失败）
+ *
  * @param signedTransactions 签名后的交易数组
  * @param config 直接广播配置
  * @returns 广播结果

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

@@ -397,6 +397,8 @@ export async function submitDirectToRpc(signedTransactions, config) {
  *
  * 每笔交易广播后会等待上链确认，确保后续交易能正确执行
  *
+ * ⚠️ 多跳场景：如果某笔交易失败，会立即停止（因为后续交易肯定也会失败）
+ *
  * @param signedTransactions 签名后的交易数组
  * @param config 直接广播配置
  * @returns 广播结果
@@ -427,7 +429,8 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
     }
     const chainId = config.chainId ?? 143;
     const chainName = config.chainName ?? 'MONAD';
-    const confirmationTimeout = config.confirmationTimeout ?? 60000; // 默认60秒超时
+    // ✅ XLayer 链默认 120 秒超时（网络可能较慢）
+    const confirmationTimeout = config.confirmationTimeout ?? (chainId === 196 ? 120000 : 60000);
     const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
         chainId,
         name: chainName
@@ -435,16 +438,19 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
     const results = [];
     const txHashes = [];
     const errors = [];
+    console.log(`📤 [${chainName}] 开始顺序广播 ${totalTransactions} 笔交易（等待每笔确认）`);
     // 顺序广播并等待确认
     for (let i = 0; i < signedTransactions.length; i++) {
         const signedTx = signedTransactions[i];
         try {
             // 广播交易
             const txResponse = await provider.broadcastTransaction(signedTx);
+            console.log(`📡 [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播成功: ${txResponse.hash}，等待确认...`);
             // ✅ 等待交易确认
             const receipt = await provider.waitForTransaction(txResponse.hash, 1, // 等待1个确认
             confirmationTimeout);
             if (receipt && receipt.status === 1) {
+                console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 已确认: ${txResponse.hash}`);
                 results.push({
                     index: i,
                     success: true,
@@ -454,6 +460,7 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
             }
             else {
                 const errorMsg = `交易执行失败（status=${receipt?.status})`;
+                console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 上链失败: ${errorMsg}`);
                 results.push({
                     index: i,
                     success: false,
@@ -461,32 +468,44 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
                     error: errorMsg
                 });
                 errors.push(`交易 ${i + 1}: ${errorMsg}`);
-                // ✅ 多跳场景：如果某笔失败，后续交易可能也会失败，继续尝试但标记
+                // ✅ 多跳场景：如果某笔失败，后续交易肯定也会失败，立即停止
+                console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
+                break;
             }
         }
         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) {
+                console.log(`🔄 [${chainName}] 交易 ${i + 1} 可能已广播，尝试等待确认: ${recovered}`);
                 // 顺序模式依赖确认：尽量等待一下
                 try {
                     const receipt = await provider.waitForTransaction(recovered, 1, confirmationTimeout);
                     if (receipt && receipt.status === 1) {
+                        console.log(`✅ [${chainName}] 交易 ${i + 1}/${totalTransactions} 恢复成功: ${recovered}`);
                         results.push({ index: i, success: true, txHash: recovered, error: errorMessage });
                         txHashes.push(recovered);
                         continue;
                     }
                     const errorMsg = `交易执行失败（status=${receipt?.status})`;
+                    console.error(`❌ [${chainName}] 交易 ${i + 1} 恢复失败: ${errorMsg}`);
                     results.push({ index: i, success: false, txHash: recovered, error: `${errorMessage} | ${errorMsg}` });
                     errors.push(`交易 ${i + 1}: ${errorMessage} | ${errorMsg}`);
-                    continue;
+                    // ✅ 多跳场景：失败则停止
+                    console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
+                    break;
                 }
-                catch {
-                    // 等待超时也先认为“已广播”，交给上层自行确认
-                    results.push({ index: i, success: true, txHash: recovered, error: errorMessage });
-                    txHashes.push(recovered);
-                    continue;
+                catch (waitError) {
+                    // 等待超时：对于多跳场景，不能假设成功，需要停止
+                    const waitErrorMsg = waitError?.message || String(waitError);
+                    console.error(`⏱️ [${chainName}] 交易 ${i + 1} 等待确认超时: ${waitErrorMsg}`);
+                    results.push({ index: i, success: false, txHash: recovered, error: `${errorMessage} | 等待确认超时: ${waitErrorMsg}` });
+                    errors.push(`交易 ${i + 1}: ${errorMessage} | 等待确认超时`);
+                    // ✅ 多跳场景：超时也停止
+                    console.warn(`⚠️ [${chainName}] 多跳模式检测到超时，停止后续 ${totalTransactions - i - 1} 笔交易`);
+                    break;
                 }
             }
             results.push({
@@ -495,11 +514,14 @@ export async function submitDirectToRpcSequential(signedTransactions, config) {
                 error: errorMessage
             });
             errors.push(`交易 ${i + 1}: ${errorMessage}`);
-            // ✅ 多跳场景：如果某笔失败，后续交易可能也会失败，继续尝试
+            // ✅ 多跳场景：如果某笔失败，后续交易肯定也会失败，立即停止
+            console.warn(`⚠️ [${chainName}] 多跳模式检测到失败，停止后续 ${totalTransactions - i - 1} 笔交易`);
+            break;
         }
     }
     const successCount = txHashes.length;
     const failedCount = totalTransactions - successCount;
+    console.log(`📊 [${chainName}] 顺序广播完成: 成功 ${successCount}/${totalTransactions}`);
     return {
         code: successCount > 0,
         totalTransactions,

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

@@ -11,3 +11,4 @@ export { pancakeProxyBatchBuyMerkle, pancakeProxyBatchSellMerkle, approvePancake
 export { flapDisperseWithBundleMerkle, flapSweepWithBundleMerkle, type FlapDisperseSignParams, type FlapDisperseMerkleResult, type FlapSweepSignParams, type FlapSweepMerkleResult } from './utils.js';
 export { flapBundleCurveToDex, type CurveToDexChain, type DexPoolType, type CurveToDexSignConfig, type CurveBuyerConfig, type DexBuyerConfig, type FlapCurveToDexParams, type FlapCurveToDexResult } from './curve-to-dex.js';
 export { flapBundleCreateToDex, type CreateToDexChain, type CreateToDexSignConfig, type CreateTokenInfo, type FlapCreateToDexParams, type FlapCreateToDexResult, type CurveBuyerConfig as CreateCurveBuyerConfig, type DexBuyerConfig as CreateDexBuyerConfig, type DexPoolType as CreateDexPoolType } from './create-to-dex.js';
+export { flapBundleSwapMerkle, flapBatchSwapMerkle, flapQuickBatchSwapMerkle, flapCrossSwapMerkle, type FlapSwapSignConfig, type FlapSwapConfig, type FlapBundleSwapSignParams, type FlapBundleSwapParams, type FlapSwapResult, type FlapBatchSwapSignParams, type FlapBatchSwapResult, type FlapQuickBatchSwapSignParams, type FlapQuickBatchSwapResult, type FlapCrossSwapParams, type FlapCrossSwapResult, type UserType } from './swap.js';

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

@@ -19,3 +19,5 @@ export { flapDisperseWithBundleMerkle, flapSweepWithBundleMerkle } from './utils
 export { flapBundleCurveToDex } from './curve-to-dex.js';
 // ✅ 发币 + 一键买到外盘（Create → Curve → DEX）- 新代币
 export { flapBundleCreateToDex } from './create-to-dex.js';
+// ✅ 内盘换手方法（一卖一买、一卖多买、快捷资金利用率、交叉换手）
+export { flapBundleSwapMerkle, flapBatchSwapMerkle, flapQuickBatchSwapMerkle, flapCrossSwapMerkle } from './swap.js';

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

@@ -144,6 +144,38 @@ export interface FlapQuickBatchSwapResult {
         disperseHopCount?: number;
     };
 }
+/** 交叉换手参数 */
+export interface FlapCrossSwapParams {
+    chain: FlapChain;
+    /** 卖方私钥列表（按顺序轮流卖出） */
+    sellerPrivateKeys: string[];
+    /** 每个卖方的卖出数量（与 sellerPrivateKeys 长度一致） */
+    sellAmounts: string[];
+    /** 买方私钥列表（按顺序轮流分配，每笔平分） */
+    buyerPrivateKeys: string[];
+    tokenAddress: string;
+    config: FlapSwapSignConfig;
+    quoteToken?: string;
+    quoteTokenDecimals?: number;
+    /** 每次卖出分配给多少个买方（默认使用全部买方平分） */
+    buyersPerSell?: number;
+    /** 转账多跳数（可选） */
+    disperseHopCount?: number;
+}
+/** 交叉换手结果 */
+export interface FlapCrossSwapResult {
+    signedTransactions: string[];
+    /** 每轮的元数据列表 */
+    rounds: Array<{
+        sellerAddress: string;
+        buyerAddresses: string[];
+        sellAmount: string;
+        bundleHash?: string;
+    }>;
+    /** 汇总的中间钱包信息（转账/利润） */
+    disperseHopWallets?: GeneratedWallet[];
+    profitHopWallets?: GeneratedWallet[];
+}
 /**
  * Flap 内盘快捷批量换手（资金利用率模式）
  *
@@ -159,3 +191,11 @@ export interface FlapQuickBatchSwapResult {
  * 限制：根据多跳数动态计算最大买方数量
  */
 export declare function flapQuickBatchSwapMerkle(params: FlapQuickBatchSwapSignParams): Promise<FlapQuickBatchSwapResult>;
+/**
+ * Flap 交叉换手（多卖多买，循环执行）
+ * - 每个卖方单独卖出，买入金额由卖出所得等分分配给当轮买方
+ * - 利润刮取、转账多跳逻辑继承 flapQuickBatchSwapMerkle
+ * - 结果按顺序拼接 signedTransactions（可交由前端/后端顺序广播）
+ * - ✅ 正确处理 nonce：同一钱包在多轮中使用时 nonce 自动递增
+ */
+export declare function flapCrossSwapMerkle(params: FlapCrossSwapParams): Promise<FlapCrossSwapResult>;

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

@@ -1222,3 +1222,136 @@ export async function flapQuickBatchSwapMerkle(params) {
         }
     };
 }
+/**
+ * Flap 交叉换手（多卖多买，循环执行）
+ * - 每个卖方单独卖出，买入金额由卖出所得等分分配给当轮买方
+ * - 利润刮取、转账多跳逻辑继承 flapQuickBatchSwapMerkle
+ * - 结果按顺序拼接 signedTransactions（可交由前端/后端顺序广播）
+ * - ✅ 正确处理 nonce：同一钱包在多轮中使用时 nonce 自动递增
+ */
+export async function flapCrossSwapMerkle(params) {
+    const { chain, sellerPrivateKeys, sellAmounts, buyerPrivateKeys, tokenAddress, config, quoteToken, quoteTokenDecimals = 18, buyersPerSell, disperseHopCount = 0 } = params;
+    if (sellerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个卖方');
+    }
+    if (sellerPrivateKeys.length !== sellAmounts.length) {
+        throw new Error(`sellAmounts 长度 (${sellAmounts.length}) 必须与卖方数量 (${sellerPrivateKeys.length}) 一致`);
+    }
+    if (buyerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个买方');
+    }
+    // ✅ 创建 Provider 和 NonceManager
+    const chainContext = createChainContext(chain, config);
+    const nonceManager = new NonceManager(chainContext.provider);
+    // ✅ 预先获取所有钱包的初始 nonce
+    const allSellerWallets = sellerPrivateKeys.map(pk => new Wallet(pk, chainContext.provider));
+    const allBuyerWallets = buyerPrivateKeys.map(pk => new Wallet(pk, chainContext.provider));
+    // 使用 Map 去重（同一私钥可能出现多次）
+    const addressToNonce = new Map();
+    // 获取所有卖方 nonce
+    for (const wallet of allSellerWallets) {
+        if (!addressToNonce.has(wallet.address)) {
+            const nonce = await nonceManager.getNextNonce(wallet);
+            addressToNonce.set(wallet.address, nonce);
+        }
+    }
+    // 获取所有买方 nonce
+    for (const wallet of allBuyerWallets) {
+        if (!addressToNonce.has(wallet.address)) {
+            const nonce = await nonceManager.getNextNonce(wallet);
+            addressToNonce.set(wallet.address, nonce);
+        }
+    }
+    console.log(`[flapCrossSwapMerkle] 初始化完成: ${sellerPrivateKeys.length} 卖方, ${buyerPrivateKeys.length} 买方`);
+    const allSigned = [];
+    const allDisperse = [];
+    const allProfit = [];
+    const rounds = [];
+    // 轮流分配买方：每轮取 buyersPerSell 个（默认所有买方），不足则从头继续
+    let buyerCursor = 0;
+    const buyerBatchSize = Math.max(1, buyersPerSell ?? buyerPrivateKeys.length);
+    for (let i = 0; i < sellerPrivateKeys.length; i++) {
+        const sellerPk = sellerPrivateKeys[i];
+        const sellAmount = sellAmounts[i];
+        const sellerWallet = allSellerWallets[i];
+        // 选取本轮买方私钥和钱包
+        const roundBuyerPks = [];
+        const roundBuyerWallets = [];
+        for (let k = 0; k < buyerBatchSize; k++) {
+            const idx = buyerCursor % buyerPrivateKeys.length;
+            roundBuyerPks.push(buyerPrivateKeys[idx]);
+            roundBuyerWallets.push(allBuyerWallets[idx]);
+            buyerCursor++;
+        }
+        // ✅ 获取卖方当前 nonce
+        const sellerNonce = addressToNonce.get(sellerWallet.address);
+        // ✅ 获取并更新买方 nonces（每个买方本轮需要 1 个 nonce）
+        const roundBuyerNonces = roundBuyerWallets.map(w => {
+            const nonce = addressToNonce.get(w.address);
+            addressToNonce.set(w.address, nonce + 1); // 每个买方用 1 个 nonce
+            return nonce;
+        });
+        // 平分买入金额（使用比例模式，避免固定金额超出可分配金额）
+        const ratio = 1 / roundBuyerPks.length;
+        const buyerRatios = roundBuyerPks.map(() => ratio);
+        // ✅ 构建 startNonces: [sellerNonce, buyer1Nonce, buyer2Nonce, ...]
+        const startNonces = [sellerNonce, ...roundBuyerNonces];
+        // ✅ 预先计算卖方 nonce 消耗（精确计算）
+        // 卖方 nonce 消耗 = 贿赂(0/1) + 卖出(1) + 转账(N 或 N*2) + 利润(1)
+        const useNativeToken = !quoteToken || quoteToken === ZERO_ADDRESS;
+        const hasBribe = getBribeAmount(config) > 0n;
+        const hasProfit = true; // 默认有利润刮取
+        let sellerNonceConsumed = 0;
+        if (hasBribe)
+            sellerNonceConsumed += 1; // 贿赂
+        sellerNonceConsumed += 1; // 卖出
+        if (disperseHopCount === 0) {
+            sellerNonceConsumed += roundBuyerPks.length; // 直接转账
+        }
+        else if (useNativeToken) {
+            sellerNonceConsumed += roundBuyerPks.length; // 原生多跳：seller→hop1
+        }
+        else {
+            sellerNonceConsumed += roundBuyerPks.length * 2; // ERC20 多跳：BNB + ERC20 两批
+        }
+        if (hasProfit)
+            sellerNonceConsumed += 1; // 利润
+        // 调用单卖多买的签名函数
+        const res = await flapQuickBatchSwapMerkle({
+            chain,
+            sellerPrivateKey: sellerPk,
+            sellAmount,
+            buyerPrivateKeys: roundBuyerPks,
+            buyerRatios,
+            tokenAddress,
+            config,
+            quoteToken,
+            quoteTokenDecimals,
+            disperseHopCount,
+            startNonces // ✅ 传入预计算的 nonces
+        });
+        // ✅ 更新卖方 nonce（使用精确计算的值）
+        addressToNonce.set(sellerWallet.address, sellerNonce + sellerNonceConsumed);
+        console.log(`[flapCrossSwapMerkle] 轮次 ${i + 1}: 卖方=${sellerWallet.address.slice(0, 10)}..., 买方=${roundBuyerPks.length}, 交易=${res.signedTransactions.length}`);
+        // 累积签名与中间钱包
+        allSigned.push(...res.signedTransactions);
+        if (res.disperseHopWallets)
+            allDisperse.push(...res.disperseHopWallets);
+        if (res.profitHopWallets)
+            allProfit.push(...res.profitHopWallets);
+        rounds.push({
+            sellerAddress: res.metadata?.sellerAddress || '',
+            buyerAddresses: res.metadata?.buyerAddresses || roundBuyerPks.map(() => ''),
+            sellAmount,
+            bundleHash: undefined
+        });
+    }
+    nonceManager.clearTemp();
+    console.log(`[flapCrossSwapMerkle] 完成: ${rounds.length} 轮, ${allSigned.length} 笔交易`);
+    return {
+        signedTransactions: allSigned,
+        rounds,
+        disperseHopWallets: allDisperse.length > 0 ? allDisperse : undefined,
+        profitHopWallets: allProfit.length > 0 ? allProfit : undefined
+    };
+}

package/dist/pancake/bundle-swap.js

@@ -1051,7 +1051,11 @@ export async function pancakeQuickBatchSwapMerkle(params) {
      } = params;
     // ✅ 判断是否使用原生代币
     const useNativeToken = !quoteToken || quoteToken === ZERO_ADDRESS;
-    const WBNB = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c'.toLowerCase();
+    // ✅ 根据 chainId 获取正确的 Wrapped Native Token 地址
+    const chainId = config.chainId ?? 56;
+    const WRAPPED_NATIVE = chainId === 196
+        ? ADDRESSES.XLAYER.WOKB.toLowerCase() // XLayer: WOKB
+        : ADDRESSES.BSC.WBNB.toLowerCase(); // BSC: WBNB
     // ✅ 动态计算最大买方数量（根据多跳数）
     // 固定开销: 贿赂(1) + 卖出(1) + 利润多跳(PROFIT_HOP_COUNT + 1)
     // BNB 模式（无多跳）: 转账(N) + 买入(N) = 2N
@@ -1108,10 +1112,11 @@ export async function pancakeQuickBatchSwapMerkle(params) {
         }
     }
     // 校验输出代币
+    const wrappedNativeName = chainId === 196 ? 'WOKB' : 'WBNB';
     if (useNativeToken) {
-        // 原生代币模式：输出必须是 WBNB
-        if (!sellOutputToken || sellOutputToken.toLowerCase() !== WBNB) {
-            throw new Error(`原生代币模式要求卖出路径以 WBNB 结尾（当前输出: ${sellOutputToken || '未知'}）。` +
+        // 原生代币模式：输出必须是 Wrapped Native Token（BSC: WBNB, XLayer: WOKB）
+        if (!sellOutputToken || sellOutputToken.toLowerCase() !== WRAPPED_NATIVE) {
+            throw new Error(`原生代币模式要求卖出路径以 ${wrappedNativeName} 结尾（当前输出: ${sellOutputToken || '未知'}）。` +
                 `请切换交易对或使用 ERC20 模式。`);
         }
     }

package/dist/xlayer/aa-transfer-profit.js

@@ -1,34 +1,72 @@
-import { ethers } from 'ethers';
+import { ethers, JsonRpcProvider } from 'ethers';
 import { PROFIT_CONFIG, ZERO_ADDRESS } from '../utils/constants.js';
 import { createAAAccountManager, createWallet, encodeExecute, encodeExecuteBatch, encodeExecuteViaMulticall3 } from './aa-account.js';
 import { quoteTokenToOkb } from './dex.js';
-import { PortalQuery } from './portal-ops.js';
+import { PortalQuery, lpFeeProfileToV3Fee } from './portal-ops.js';
+import { WOKB, DEFAULT_RPC_URL, XLAYER_CHAIN_ID } from './constants.js';
+import { quoteV3 } from '../utils/quote-helpers.js';
 /**
  * ✅ 获取 Token → OKB 报价（带回退逻辑）
- * 和 bundle.ts 保持一致：先尝试 V2，失败后回退到 Flap Portal
+ * 改进版：V2 → V3 → Flap Portal，确保尽可能获取报价
  */
 async function quoteTokenToOkbWithFallback(tokenAmount, tokenAddress, config) {
     if (tokenAmount <= 0n)
         return 0n;
+    const rpcUrl = config.rpcUrl || DEFAULT_RPC_URL;
+    const chainId = config.chainId ?? XLAYER_CHAIN_ID;
     // 1. 先尝试 V2 报价
     try {
-        const okbOut = await quoteTokenToOkb(tokenAmount, tokenAddress, { rpcUrl: config.rpcUrl });
-        if (okbOut > 0n)
+        const okbOut = await quoteTokenToOkb(tokenAmount, tokenAddress, { rpcUrl });
+        if (okbOut > 0n) {
+            console.log(`[quoteTokenToOkbWithFallback] V2 报价成功: ${ethers.formatEther(okbOut)} OKB`);
             return okbOut;
+        }
     }
-    catch {
-        // V2 报价失败，继续尝试 Flap
+    catch (e) {
+        // V2 报价失败，继续尝试 V3
+        console.log(`[quoteTokenToOkbWithFallback] V2 报价失败，尝试 V3...`);
     }
-    // 2. 回退到 Flap Portal 报价
+    // 2. 尝试 V3 报价
     try {
-        const portalQuery = new PortalQuery({ rpcUrl: config.rpcUrl, chainId: config.chainId ?? 196 });
+        // 先尝试从 Portal 获取代币的 lpFeeProfile 来确定正确的 fee
+        let preferredFee;
+        try {
+            const portalQuery = new PortalQuery({ rpcUrl, chainId });
+            const tokenState = await portalQuery.getTokenV7(tokenAddress);
+            preferredFee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+            console.log(`[quoteTokenToOkbWithFallback] 从 Portal 获取 lpFeeProfile=${tokenState.lpFeeProfile} → fee=${preferredFee}`);
+        }
+        catch {
+            // 无法获取 lpFeeProfile（可能是纯外盘代币），让 quoteV3 自动尝试所有费率
+            console.log(`[quoteTokenToOkbWithFallback] 无法获取 lpFeeProfile，将尝试所有 V3 费率档位`);
+        }
+        // 使用 V3 Quoter 报价（Token → WOKB）
+        // 如果有 preferredFee 则优先尝试，否则自动尝试所有费率 [100, 500, 2500, 10000]
+        const provider = new JsonRpcProvider(rpcUrl, { chainId, name: 'xlayer', ensAddress: undefined });
+        const quoteResult = await quoteV3(provider, tokenAddress, WOKB, tokenAmount, 'XLAYER', preferredFee);
+        if (quoteResult.amountOut > 0n) {
+            console.log(`[quoteTokenToOkbWithFallback] V3 报价成功 (fee=${quoteResult.fee}): ${ethers.formatEther(quoteResult.amountOut)} OKB`);
+            return quoteResult.amountOut;
+        }
+    }
+    catch (e) {
+        // V3 报价失败，继续尝试 Flap
+        console.log(`[quoteTokenToOkbWithFallback] V3 报价失败，尝试 Flap Portal...`);
+    }
+    // 3. 回退到 Flap Portal 报价
+    try {
+        const portalQuery = new PortalQuery({ rpcUrl, chainId });
         const okbOut = await portalQuery.quoteExactInput(tokenAddress, ZERO_ADDRESS, tokenAmount);
-        if (okbOut > 0n)
+        if (okbOut > 0n) {
+            console.log(`[quoteTokenToOkbWithFallback] Flap Portal 报价成功: ${ethers.formatEther(okbOut)} OKB`);
             return okbOut;
+        }
     }
-    catch {
+    catch (e) {
         // Flap 报价也失败
+        console.log(`[quoteTokenToOkbWithFallback] Flap Portal 报价失败`);
     }
+    console.warn(`[quoteTokenToOkbWithFallback] 所有报价方式都失败，无法获取 ${tokenAddress} 的 OKB 价值`);
     return 0n;
 }
 function clampBps(bps) {
@@ -88,10 +126,11 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
     ]);
     // 计算总金额与利润
     // ✅ Native：利润从总额中扣除，保留在 AA 钱包
-    // ✅ ERC20：代币全额分发，利润以 OKB 形式收取（需要报价）
+    // ✅ ERC20：优先以 OKB 形式收取利润，报价失败时直接刮取 ERC20 代币
     let totalWei = 0n;
-    let profitWei = 0n; // ✅ 利润（OKB wei）
-    let profitIsOkb = false; // ✅ 标记利润是否为 OKB（用于 ERC20）
+    let profitWei = 0n; // ✅ OKB 利润（当报价成功时）
+    let profitTokenWei = 0n; // ✅ ERC20 代币利润（当报价失败时）
+    let profitIsOkb = false; // ✅ 标记利润是否为 OKB
     if (params.kind === 'native') {
         const values = amtList.map((x) => {
             const v = ethers.parseEther(String(x || '0'));
@@ -113,29 +152,43 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
             return v > 0n ? v : 0n;
         });
         totalWei = values.reduce((a, b) => a + b, 0n);
-        // ✅ ERC20：报价获取代币的 OKB 价值，然后计算 OKB 利润
-        // 和 bundle.ts/wash-ops.ts 保持一致：先尝试 V2，失败后回退到 Flap Portal
+        // ✅ ERC20：尝试报价获取 OKB 价值
+        // 报价成功 → 收取 OKB 利润
+        // 报价失败 → 直接刮取 ERC20 代币作为利润（不跳过！）
         if (totalWei > 0n) {
             const okbValueWei = await quoteTokenToOkbWithFallback(totalWei, token, { rpcUrl: effConfig.rpcUrl, chainId: effConfig.chainId });
             if (okbValueWei > 0n) {
                 profitWei = calcProfitWei(okbValueWei, PROFIT_CONFIG.RATE_BPS);
+                profitTokenWei = 0n;
                 profitIsOkb = true;
-                console.log(`[AA 分发] ERC20 报价: ${ethers.formatUnits(totalWei, dec)} Token = ${ethers.formatEther(okbValueWei)} OKB, 利润: ${ethers.formatEther(profitWei)} OKB`);
+                console.log(`[AA 分发] ERC20 报价成功: ${ethers.formatUnits(totalWei, dec)} Token = ${ethers.formatEther(okbValueWei)} OKB, 利润: ${ethers.formatEther(profitWei)} OKB`);
             }
             else {
-                console.warn('[AA 分发] ERC20 报价失败（V2 和 Flap 都无法获取价格），跳过利润收取');
+                // ✅ 报价失败：直接从代币金额中扣除利润（ERC20 代币形式）
+                profitTokenWei = calcProfitWei(totalWei, PROFIT_CONFIG.RATE_BPS);
                 profitWei = 0n;
                 profitIsOkb = false;
+                console.warn(`[AA 分发] ERC20 报价失败，改为刮取 ERC20 代币: ${ethers.formatUnits(profitTokenWei, dec)} Token`);
             }
         }
     }
-    // ✅ Native：扣除利润后分发；ERC20：全额分发（利润另外以 OKB 转账）
-    const distributableWei = params.kind === 'native'
-        ? (totalWei > profitWei ? (totalWei - profitWei) : 0n)
-        : totalWei;
+    // ✅ 计算可分发金额
+    // Native：扣除利润后分发
+    // ERC20（报价成功）：全额分发代币，利润另外以 OKB 转账
+    // ERC20（报价失败）：扣除代币利润后分发
+    let distributableWei;
+    if (params.kind === 'native') {
+        distributableWei = totalWei > profitWei ? (totalWei - profitWei) : 0n;
+    }
+    else if (profitIsOkb) {
+        // 报价成功：全额分发代币
+        distributableWei = totalWei;
+    }
+    else {
+        // 报价失败：扣除代币利润后分发
+        distributableWei = totalWei > profitTokenWei ? (totalWei - profitTokenWei) : 0n;
+    }
     // 按比例缩放每个收款金额
-    // ✅ Native：使"总分发=总额-利润"；利润保留在 AA 钱包
-    // ✅ ERC20：全额分发代币，利润以 OKB 单独转账
     const scaled = [];
     if (totalWei > 0n && distributableWei > 0n) {
         if (params.kind === 'native') {
@@ -162,11 +215,28 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
             }
         }
         else {
-            // ✅ ERC20：全额分发，不缩放
+            // ✅ ERC20：按比例缩放分发金额
             const dec = Number(params.tokenDecimals);
-            for (const x of amtList) {
+            const raw = amtList.map((x) => {
                 const v = ethers.parseUnits(String(x || '0'), dec);
-                scaled.push(v > 0n ? v : 0n);
+                return v > 0n ? v : 0n;
+            });
+            let acc = 0n;
+            for (let i = 0; i < raw.length; i++) {
+                const v = raw[i];
+                const out = (v * distributableWei) / totalWei;
+                scaled.push(out);
+                acc += out;
+            }
+            // 把余数补到最后一个非 0 位置
+            const rem = distributableWei - acc;
+            if (rem > 0n) {
+                for (let i = scaled.length - 1; i >= 0; i--) {
+                    if (scaled[i] > 0n || raw[i] > 0n) {
+                        scaled[i] = scaled[i] + rem;
+                        break;
+                    }
+                }
             }
         }
     }
@@ -244,9 +314,13 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
         }
         else {
             // ERC20 转账：executeBatch 或 Multicall3
-            // ✅ 如果有 OKB 利润转账，必须使用 Multicall3（SimpleAccount 不支持带 values 的 executeBatch）
             const token = String(params.tokenAddress || '').trim();
+            // ✅ 利润处理：
+            // - 报价成功（profitIsOkb）：OKB 利润转账
+            // - 报价失败（!profitIsOkb && profitTokenWei > 0n）：ERC20 代币利润转账
             const hasOkbProfit = i === 0 && profitIsOkb && profitWei > 0n;
+            const hasTokenProfit = i === 0 && !profitIsOkb && profitTokenWei > 0n;
+            const hasAnyProfit = hasOkbProfit || hasTokenProfit;
             let callData;
             if (hasOkbProfit) {
                 // ✅ 使用 Multicall3：ERC20 转账 + OKB 利润转账
@@ -266,8 +340,24 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
                 });
                 callData = encodeExecuteViaMulticall3(calls);
             }
+            else if (hasTokenProfit) {
+                // ✅ 报价失败：ERC20 转账 + ERC20 代币利润转账
+                const dests = [];
+                const values = [];
+                const datas = [];
+                for (const it of list) {
+                    dests.push(token);
+                    values.push(0n);
+                    datas.push(erc20Iface.encodeFunctionData('transfer', [it.to, it.amountWei]));
+                }
+                // 添加 ERC20 代币利润转账
+                dests.push(token);
+                values.push(0n);
+                datas.push(erc20Iface.encodeFunctionData('transfer', [PROFIT_CONFIG.RECIPIENT, profitTokenWei]));
+                callData = encodeExecuteBatch(dests, values, datas);
+            }
             else {
-                // 无利润：使用 executeBatch（所有 values 都是 0，兼容）
+                // 无利润：使用 executeBatch
                 const dests = [];
                 const values = [];
                 const datas = [];
@@ -281,8 +371,8 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
             const nonce = nonce0 + BigInt(i);
             const initCode = i === 0 ? String(initCode0) : '0x';
             const deployed = i === 0 ? deployed0 : true;
-            // ✅ 计算 gas，包含 OKB 利润转账
-            const transferCount = list.length + (hasOkbProfit ? 1 : 0);
+            // ✅ 计算 gas，包含利润转账
+            const transferCount = list.length + (hasAnyProfit ? 1 : 0);
             const base = hasOkbProfit ? 250000n : 220000n; // Multicall3 需要更多基础 gas
             const per = 65000n;
             const g = base + per * BigInt(transferCount);
@@ -300,7 +390,9 @@ export async function buildDisperseFromSingleOwnerOpsWithProfit(params) {
             ops.push(signed.userOp);
         }
     }
-    return { ops, sender, profitWei };
+    // ✅ 返回利润：OKB 利润或 ERC20 代币利润（用 profitWei 表示，方便上层处理）
+    const finalProfitWei = profitIsOkb ? profitWei : profitTokenWei;
+    return { ops, sender, profitWei: finalProfitWei };
 }
 /**
  * ✅ XLayer AA：多 owner 归集/转账（SDK 安全版，内置利润）
@@ -382,7 +474,7 @@ export async function buildTransfersWithProfit(params) {
         return (totalGas * gasPrice * 130n) / 100n;
     };
     // ✅ 第一步：计算每个钱包的归集金额和总利润
-    // 利润从每个钱包的归集金额中扣除，但只由第一个有效钱包统一转账给利润地址
+    // 利润从每个钱包的归集金额中扣除
     const transferInfos = [];
     for (let i = 0; i < ownerWallets.length; i++) {
         const sender = senders[i];
@@ -406,55 +498,66 @@ export async function buildTransfersWithProfit(params) {
             continue;
         const deployed = accountInfos[i]?.deployed ?? false;
         const prefundWei = params.kind === 'native' ? estimateTransferPrefund(deployed) : 0n;
-        // ✅ Native：利润从金额中扣除，保留在 AA 钱包（以 OKB 形式）
-        // ✅ ERC20：代币全额分发，利润以 OKB 形式收取（需报价）
+        // ✅ 利润处理
         let profitWei = 0n;
+        let profitTokenWei = 0n;
+        let profitIsOkb = false;
         let toWei = amountWei;
         if (params.kind === 'native') {
             profitWei = calcProfitWei(amountWei, PROFIT_CONFIG.RATE_BPS);
+            profitIsOkb = false; // Native 模式下利润就是 OKB，但走 Native 逻辑
             // ✅ 关键修复：toWei 需要扣除 max(profitWei, prefundWei)，确保留足够的 gas
             const reserveWei = profitWei > prefundWei ? profitWei : prefundWei;
             toWei = amountWei > reserveWei ? (amountWei - reserveWei) : 0n;
             totalProfitWei += profitWei;
         }
         else {
-            // ✅ ERC20：全额分发代币，利润以 OKB 形式收取
-            // 和 bundle.ts/wash-ops.ts 保持一致：先尝试 V2，失败后回退到 Flap Portal
-            toWei = amountWei;
+            // ✅ ERC20：尝试报价，报价失败则直接刮取 ERC20 代币
             const token = String(params.tokenAddress || '').trim();
-            // ✅ 关键修复：检查 AA 钱包是否有足够的 OKB 余额支付利润
-            // 如果 AA 钱包 OKB 余额不足，跳过利润收取，只转 ERC20 代币
             const aaOkbBalance = accountInfos[i]?.okbBalance ?? 0n;
             const okbValueWei = await quoteTokenToOkbWithFallback(amountWei, token, { rpcUrl: effConfig.rpcUrl, chainId: effConfig.chainId });
             if (okbValueWei > 0n) {
                 const calculatedProfit = calcProfitWei(okbValueWei, PROFIT_CONFIG.RATE_BPS);
-                // ✅ 只有当 AA 钱包 OKB 余额 >= 利润 + prefund 时才收取利润
-                // prefund 预留 0.0001 OKB (100_000_000_000_000 wei)
                 const minReserve = 100000000000000n; // 0.0001 OKB
                 if (aaOkbBalance >= calculatedProfit + minReserve) {
+                    // ✅ 报价成功且余额充足：收取 OKB 利润
                     profitWei = calculatedProfit;
+                    profitTokenWei = 0n;
+                    profitIsOkb = true;
+                    toWei = amountWei; // ERC20 全额转账
                     totalProfitWei += profitWei;
+                    console.log(`[AA 归集] 钱包 ${i} 报价成功: 收取 ${ethers.formatEther(profitWei)} OKB 利润`);
                 }
                 else {
-                    console.warn(`[AA 归集] 钱包 ${i} OKB 余额不足 (${ethers.formatEther(aaOkbBalance)} OKB < 需要 ${ethers.formatEther(calculatedProfit + minReserve)} OKB)，跳过利润收取`);
+                    // ✅ 余额不足：改为刮取 ERC20 代币
+                    profitTokenWei = calcProfitWei(amountWei, PROFIT_CONFIG.RATE_BPS);
                     profitWei = 0n;
+                    profitIsOkb = false;
+                    toWei = amountWei > profitTokenWei ? (amountWei - profitTokenWei) : 0n;
+                    totalProfitWei += profitTokenWei;
+                    console.warn(`[AA 归集] 钱包 ${i} OKB 余额不足，改为刮取 ERC20 代币: ${ethers.formatUnits(profitTokenWei, Number(params.tokenDecimals))} Token`);
                 }
             }
             else {
-                console.warn(`[AA 归集] ERC20 报价失败 (钱包 ${i})，跳过利润收取`);
+                // ✅ 报价失败：直接刮取 ERC20 代币（不跳过！）
+                profitTokenWei = calcProfitWei(amountWei, PROFIT_CONFIG.RATE_BPS);
                 profitWei = 0n;
+                profitIsOkb = false;
+                toWei = amountWei > profitTokenWei ? (amountWei - profitTokenWei) : 0n;
+                totalProfitWei += profitTokenWei;
+                console.warn(`[AA 归集] 钱包 ${i} 报价失败，改为刮取 ERC20 代币: ${ethers.formatUnits(profitTokenWei, Number(params.tokenDecimals))} Token`);
             }
         }
-        transferInfos.push({ walletIndex: i, sender, to, amountWei, profitWei, toWei, prefundWei });
+        transferInfos.push({ walletIndex: i, sender, to, amountWei, profitWei, profitTokenWei, profitIsOkb, toWei, prefundWei });
     }
-    console.log(`[AA 归集] 钱包数量: ${transferInfos.length}, 总利润: ${ethers.formatEther(totalProfitWei)} OKB`);
+    console.log(`[AA 归集] 钱包数量: ${transferInfos.length}, 总利润: ${ethers.formatEther(totalProfitWei)}`);
     const unsigned = [];
     const opOwnerIndex = [];
     // ✅ 第二步：构建 UserOps
     // Native: 单个 UserOp，转 toWei 给目标地址，利润保留在 AA 钱包
-    // ERC20: 两个 UserOp（如果有利润）
-    //   - UserOp 1: 转 ERC20 代币给目标地址
-    //   - UserOp 2: 转 OKB 利润给利润接收者
+    // ERC20: 
+    //   - 报价成功（profitIsOkb）：UserOp 1 转代币 + UserOp 2 转 OKB 利润
+    //   - 报价失败（!profitIsOkb）：单个 UserOp 用 executeBatch 转代币 + 代币利润
     for (let idx = 0; idx < transferInfos.length; idx++) {
         const info = transferInfos[idx];
         const i = info.walletIndex;
@@ -478,38 +581,76 @@ export async function buildTransfersWithProfit(params) {
             opOwnerIndex.push(i);
         }
         else {
-            // ✅ ERC20：两个 UserOp
             const token = String(params.tokenAddress || '').trim();
-            // UserOp 1: 转 ERC20 代币给目标地址
-            const transfer = erc20Iface.encodeFunctionData('transfer', [info.to, info.toWei]);
-            const erc20CallData = encodeExecute(token, 0n, transfer);
-            const erc20Built = await aaManager.buildUserOpWithFixedGas({
-                ownerWallet: w,
-                sender: info.sender,
-                callData: erc20CallData,
-                nonce: currentNonce,
-                initCode,
-                deployed: initCode === '0x',
-                fixedGas: { callGasLimit: 200000n },
-            });
-            unsigned.push(erc20Built.userOp);
-            opOwnerIndex.push(i);
-            currentNonce += 1n;
-            // UserOp 2: 转 OKB 利润给利润接收者（如果有利润）
-            if (info.profitWei > 0n) {
+            if (info.profitIsOkb && info.profitWei > 0n) {
+                // ✅ 报价成功：两个 UserOp（ERC20 转账 + OKB 利润转账）
+                // UserOp 1: 转 ERC20 代币给目标地址
+                const transfer = erc20Iface.encodeFunctionData('transfer', [info.to, info.toWei]);
+                const erc20CallData = encodeExecute(token, 0n, transfer);
+                const erc20Built = await aaManager.buildUserOpWithFixedGas({
+                    ownerWallet: w,
+                    sender: info.sender,
+                    callData: erc20CallData,
+                    nonce: currentNonce,
+                    initCode,
+                    deployed: initCode === '0x',
+                    fixedGas: { callGasLimit: 200000n },
+                });
+                unsigned.push(erc20Built.userOp);
+                opOwnerIndex.push(i);
+                currentNonce += 1n;
+                // UserOp 2: 转 OKB 利润给利润接收者
                 const profitCallData = encodeExecute(PROFIT_CONFIG.RECIPIENT, info.profitWei, '0x');
                 const profitBuilt = await aaManager.buildUserOpWithFixedGas({
                     ownerWallet: w,
                     sender: info.sender,
                     callData: profitCallData,
                     nonce: currentNonce,
-                    initCode: '0x', // 第二个 UserOp 不需要 initCode
+                    initCode: '0x',
                     deployed: true,
                     fixedGas: { callGasLimit: 120000n },
                 });
                 unsigned.push(profitBuilt.userOp);
                 opOwnerIndex.push(i);
-                console.log(`[AA 归集] 钱包 ${i} 创建利润转账 UserOp: ${ethers.formatEther(info.profitWei)} OKB → ${PROFIT_CONFIG.RECIPIENT}`);
+                console.log(`[AA 归集] 钱包 ${i} 创建 OKB 利润转账 UserOp: ${ethers.formatEther(info.profitWei)} OKB → ${PROFIT_CONFIG.RECIPIENT}`);
+            }
+            else if (!info.profitIsOkb && info.profitTokenWei > 0n) {
+                // ✅ 报价失败：单个 UserOp，使用 executeBatch 同时转代币和代币利润
+                const dests = [token, token];
+                const values = [0n, 0n];
+                const datas = [
+                    erc20Iface.encodeFunctionData('transfer', [info.to, info.toWei]),
+                    erc20Iface.encodeFunctionData('transfer', [PROFIT_CONFIG.RECIPIENT, info.profitTokenWei]),
+                ];
+                const batchCallData = encodeExecuteBatch(dests, values, datas);
+                const batchBuilt = await aaManager.buildUserOpWithFixedGas({
+                    ownerWallet: w,
+                    sender: info.sender,
+                    callData: batchCallData,
+                    nonce: currentNonce,
+                    initCode,
+                    deployed: initCode === '0x',
+                    fixedGas: { callGasLimit: 300000n }, // 批量操作需要更多 gas
+                });
+                unsigned.push(batchBuilt.userOp);
+                opOwnerIndex.push(i);
+                console.log(`[AA 归集] 钱包 ${i} 创建 ERC20 代币利润转账: ${ethers.formatUnits(info.profitTokenWei, Number(params.tokenDecimals))} Token → ${PROFIT_CONFIG.RECIPIENT}`);
+            }
+            else {
+                // ✅ 无利润：只转代币
+                const transfer = erc20Iface.encodeFunctionData('transfer', [info.to, info.toWei]);
+                const erc20CallData = encodeExecute(token, 0n, transfer);
+                const erc20Built = await aaManager.buildUserOpWithFixedGas({
+                    ownerWallet: w,
+                    sender: info.sender,
+                    callData: erc20CallData,
+                    nonce: currentNonce,
+                    initCode,
+                    deployed: initCode === '0x',
+                    fixedGas: { callGasLimit: 200000n },
+                });
+                unsigned.push(erc20Built.userOp);
+                opOwnerIndex.push(i);
             }
         }
     }

package/package.json

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