four-flap-meme-sdk 1.7.61 → 1.7.63

package/dist/eip7702/xlayer/bundle-swap.d.ts

@@ -13,10 +13,22 @@ import type { BundleSwapParams as BaseBundleSwapParams, BundleBatchSwapParams as
 export interface BundleSwapParams extends BaseBundleSwapParams {
     /** 用户类型（影响利润率） */
     userType?: UserType;
+    /**
+     * 是否使用资金利用率模式（默认 false）
+     * - false（普通模式）: 卖家卖出 OKB 留在卖家账户，买家用自己预存的 OKB 买入
+     * - true（资金利用率模式）: 卖家卖出的 OKB 通过多跳转账给买家，买家用收到的 OKB 买入
+     */
+    useFundUtilization?: boolean;
 }
 export interface BundleBatchSwapParams extends BaseBundleBatchSwapParams {
     /** 用户类型（影响利润率） */
     userType?: UserType;
+    /**
+     * 是否使用资金利用率模式（默认 false）
+     * - false（普通模式）: 卖家卖出 OKB 留在卖家账户，买家用自己预存的 OKB 买入
+     * - true（资金利用率模式）: 卖家卖出的 OKB 通过多跳转账给买家，买家用收到的 OKB 买入
+     */
+    useFundUtilization?: boolean;
 }
 import { type UserType } from './utils.js';
 /**

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

@@ -291,8 +291,7 @@ tokenAddress, tradeType, routerAddress, fee) {
  * });
  */
 export async function bundleSwap(params) {
-    const { sellerPrivateKey, buyerPrivateKey, tokenAddress, tokenDecimals = 18, sellAmount, hopCount = 2, // ✅ 设为 0 则不多跳，直接 seller → buyer
-    tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', // ✅ 用户类型（影响利润率）
+    const { sellerPrivateKey, buyerPrivateKey, tokenAddress, tokenDecimals = 18, sellAmount, hopCount = 0, tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', useFundUtilization = false, // ✅ 默认普通模式
     config, } = params;
     const provider = getCachedProvider(config?.rpcUrl);
     const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
@@ -304,84 +303,140 @@ export async function bundleSwap(params) {
     // ========================================
     const sellerWallet = createWallet(sellerPrivateKey, provider);
     const buyerWallet = createWallet(buyerPrivateKey, provider);
-    // 生成中间钱包（hopCount = 0 时不生成）
-    const hopWalletInfos = hopCount > 0 ? generateRandomWallets(hopCount) : [];
+    // 资金利用率模式才需要中间钱包
+    const actualHopCount = useFundUtilization ? hopCount : 0;
+    const hopWalletInfos = actualHopCount > 0 ? generateRandomWallets(actualHopCount) : [];
     const hopWallets = hopWalletInfos.map(info => createWallet(info.privateKey, provider));
     const sellAmountWei = ethers.parseUnits(truncateDecimals(sellAmount, tokenDecimals), tokenDecimals);
-    // ✅ 修复：获取卖出报价，基于预估的 OKB 输出计算利润
+    // 获取卖出报价
     const estimatedOkbOut = await quoteSellOutput(sellAmountWei, tokenAddress, tradeType, fee, config?.rpcUrl);
     // 使用双边费率计算利润（换手 = 卖 + 买）
     const profitAmount = estimatedOkbOut > 0n
-        ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true) // isDoubleMode = true
+        ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true)
         : 0n;
     const profitRecipient = getProfitRecipient(config);
+    // 计算买入金额
+    const buyAmountAfterProfit = estimatedOkbOut > profitAmount
+        ? estimatedOkbOut - profitAmount
+        : 0n;
+    const modeLabel = useFundUtilization ? '资金利用率' : '普通';
+    console.log(`[Bundle Swap] 模式: ${modeLabel}`);
     console.log(`[Bundle Swap] 卖出数量: ${sellAmount} Token`);
     console.log(`[Bundle Swap] 预估获得: ${ethers.formatEther(estimatedOkbOut)} OKB`);
     console.log(`[Bundle Swap] 利润: ${ethers.formatEther(profitAmount)} OKB (userType=${userType})`);
+    console.log(`[Bundle Swap] 买入金额: ${ethers.formatEther(buyAmountAfterProfit)} OKB`);
     // ========================================
-    // 并行获取所有异步数据
+    // 并行获取数据
     // ========================================
     const [nonces, feeData, buyerBalance] = await Promise.all([
-        // 并行获取 seller 和 buyer 的 nonce
         batchGetNonces([sellerWallet.address, buyerWallet.address], provider),
-        // 获取 gas 费用数据
         provider.getFeeData(),
-        // 获取买家的 OKB 余额（普通模式下买家用自己的钱）
         provider.getBalance(buyerWallet.address),
     ]);
     const sellerNonce = nonces[0];
     const buyerNonce = nonces[1];
-    console.log(`[Bundle Swap] 买家 OKB 余额: ${ethers.formatEther(buyerBalance)} OKB`);
     // ========================================
-    // 同步签署授权（只需要卖家和买家，不需要 hop wallets）
+    // 验证余额
     // ========================================
-    const authorizations = [];
-    // 卖家授权（交易发起者，nonce +1）
-    authorizations.push(signAuthorization(sellerWallet, delegateAddress, BigInt(sellerNonce + 1)));
-    // 买家授权
-    authorizations.push(signAuthorization(buyerWallet, delegateAddress, BigInt(buyerNonce)));
-    // 等待所有授权签名完成
-    const resolvedAuthorizations = await Promise.all(authorizations);
+    if (tradeType === 'FLAP' && buyAmountAfterProfit <= 0n) {
+        throw new Error('FLAP 内盘模式需要有效的报价，请检查代币地址或稍后重试');
+    }
+    // 普通模式：买家需要预存足够的 OKB
+    if (!useFundUtilization && tradeType === 'FLAP') {
+        if (buyerBalance < buyAmountAfterProfit) {
+            throw new Error(`普通模式需要买家钱包有足够的 OKB，需要 ${ethers.formatEther(buyAmountAfterProfit)}，当前 ${ethers.formatEther(buyerBalance)}`);
+        }
+    }
     // ========================================
-    // 同步构建调用
+    // 签署授权
     // ========================================
-    // ✅ 计算买入金额（普通模式：买家用自己的 OKB）
-    // FLAP 模式需要使用买家的实际余额，扣除利润后的金额
-    const buyerAvailable = buyerBalance > profitAmount ? buyerBalance - profitAmount : 0n;
-    console.log(`[Bundle Swap] 买家可用金额（扣除利润后）: ${ethers.formatEther(buyerAvailable)} OKB`);
-    // ✅ FLAP 模式需要买家有足够的 OKB
-    if (tradeType === 'FLAP' && buyerAvailable <= 0n) {
-        throw new Error('FLAP 内盘模式需要买家钱包有足够的 OKB');
+    const authPromises = [];
+    // 卖家授权（交易发起者，nonce +1）
+    authPromises.push(signAuthorization(sellerWallet, delegateAddress, BigInt(sellerNonce + 1)));
+    // 买家授权
+    authPromises.push(signAuthorization(buyerWallet, delegateAddress, BigInt(buyerNonce)));
+    // 中间钱包授权（资金利用率模式）
+    for (const hopWallet of hopWallets) {
+        authPromises.push(signAuthorization(hopWallet, delegateAddress, 0n));
     }
-    const calls = [];
+    const authorizations = await Promise.all(authPromises);
     // ========================================
-    // ✅ 普通换手模式逻辑
-    // 1. 卖家卖出代币 → OKB 留在卖家账户
-    // 2. 买家用自己预存的 OKB 买入代币
-    // 3. 利润从买家的 OKB 中扣除
+    // 构建调用
     // ========================================
-    // 1. 卖家卖出（OKB 留在卖家账户，不转给买家）
-    const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
-    calls.push(sellCall);
-    // 2. 利润刮取（从买家余额扣除，在买入之前）
-    if (profitAmount > 0n) {
+    const calls = [];
+    if (useFundUtilization) {
+        // ========================================
+        // ✅ 资金利用率模式
+        // 1. 卖家卖出代币 → 获得 OKB
+        // 2. OKB 多跳转账 → 中间钱包1 → 中间钱包2 → ... → 买家
+        // 3. 利润从卖家 OKB 中扣除
+        // 4. 买家用收到的 OKB 买入
+        // ========================================
+        console.log(`[Bundle Swap] 资金利用率模式，hopCount=${actualHopCount}`);
+        // 1. 卖家卖出
+        const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(sellCall);
+        // 2. 利润刮取（从卖家余额扣除）
+        if (profitAmount > 0n) {
+            calls.push({
+                target: sellerWallet.address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
+            });
+        }
+        // 3. OKB 多跳转账（卖家 → hop1 → hop2 → ... → 买家）
+        const firstRecipient = hopWallets.length > 0 ? hopWallets[0].address : buyerWallet.address;
+        // 卖家 → 第一个接收者
         calls.push({
-            target: buyerWallet.address,
+            target: sellerWallet.address,
             allowFailure: false,
             value: 0n,
-            callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
+            callData: delegateInterface.encodeFunctionData('transferTo', [firstRecipient]),
         });
+        // 中间钱包之间转账
+        for (let i = 0; i < hopWallets.length; i++) {
+            const nextRecipient = i < hopWallets.length - 1 ? hopWallets[i + 1].address : buyerWallet.address;
+            calls.push({
+                target: hopWallets[i].address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferTo', [nextRecipient]),
+            });
+        }
+        // 4. 买家买入（使用收到的全部 OKB）
+        const buyCall = buildBuyCallInternal(buyerWallet, tradeType === 'FLAP' ? buyAmountAfterProfit : 0n, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(buyCall);
+    }
+    else {
+        // ========================================
+        // ✅ 普通模式
+        // 1. 卖家卖出代币 → OKB 留在卖家账户
+        // 2. 买家用自己预存的 OKB 买入代币
+        // 3. 利润从买家的 OKB 中扣除
+        // ========================================
+        console.log(`[Bundle Swap] 普通模式`);
+        // 1. 卖家卖出（OKB 留在卖家账户）
+        const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(sellCall);
+        // 2. 利润刮取（从买家余额扣除）
+        if (profitAmount > 0n) {
+            calls.push({
+                target: buyerWallet.address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
+            });
+        }
+        // 3. 买家用自己的 OKB 买入
+        const buyAmountForCall = tradeType === 'FLAP' ? buyAmountAfterProfit : 0n;
+        const buyCall = buildBuyCallInternal(buyerWallet, buyAmountForCall, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(buyCall);
     }
-    // 3. 买家用自己预存的 OKB 买入
-    // ✅ FLAP 模式使用买家实际余额（扣除利润后），V2/V3 模式使用 0n（合约自动使用全部余额）
-    const buyAmountForCall = tradeType === 'FLAP' ? buyerAvailable : 0n;
-    const buyCall = buildBuyCallInternal(buyerWallet, buyAmountForCall, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
-    calls.push(buyCall);
     // ========================================
-    // 同步构建交易
+    // 构建交易
     // ========================================
-    const signedTransaction = buildEIP7702TransactionSync(sellerWallet, resolvedAuthorizations, calls, 0n, // ✅ 修复：利润使用 transferAmount 从卖家余额转账，不需要通过 msg.value 传递
-    sellerNonce, feeData, config);
+    const signedTransaction = buildEIP7702TransactionSync(sellerWallet, authorizations, calls, 0n, sellerNonce, feeData, config);
     return {
         signedTransaction,
         hopWallets: hopWalletInfos,
@@ -389,11 +444,12 @@ export async function bundleSwap(params) {
             sellerAddress: sellerWallet.address,
             buyerAddresses: [buyerWallet.address],
             sellAmount: ethers.formatUnits(sellAmountWei, tokenDecimals),
-            estimatedOkbOut: ethers.formatEther(estimatedOkbOut), // ✅ 预估卖出所得 OKB
-            estimatedBuyAmount: '0',
-            profitAmount: ethers.formatEther(profitAmount), // ✅ 利润是 OKB
+            estimatedOkbOut: ethers.formatEther(estimatedOkbOut),
+            estimatedBuyAmount: ethers.formatEther(buyAmountAfterProfit),
+            profitAmount: ethers.formatEther(profitAmount),
             profitRecipient,
             userType,
+            useFundUtilization,
         },
     };
 }
@@ -414,109 +470,189 @@ export async function bundleSwap(params) {
  * });
  */
 export async function bundleBatchSwap(params) {
-    const { sellerPrivateKey, buyerPrivateKeys, buyerRatios, // ✅ 添加：前端传入的分配比例
-    tokenAddress, tokenDecimals = 18, sellAmount, hopCount = 2, // ✅ 设为 0 则不多跳
-    tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', // ✅ 用户类型（影响利润率）
+    const { sellerPrivateKey, buyerPrivateKeys, buyerRatios, tokenAddress, tokenDecimals = 18, sellAmount, hopCount = 0, tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', useFundUtilization = false, // ✅ 默认普通模式
     config, } = params;
     const provider = getCachedProvider(config?.rpcUrl);
     const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
     const actualRouter = routerAddress ?? getDefaultRouter(tradeType);
+    const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
+    const portalInterface = new ethers.Interface(FLAP_PORTAL_ABI);
     // ========================================
-    // 同步操作 - 创建钱包
+    // 创建钱包
     // ========================================
     const sellerWallet = createWallet(sellerPrivateKey, provider);
     const buyerWallets = buyerPrivateKeys.map(pk => createWallet(pk, provider));
-    const hopWalletInfos = hopCount > 0 ? generateRandomWallets(hopCount) : [];
+    // 资金利用率模式才需要中间钱包
+    const actualHopCount = useFundUtilization ? hopCount : 0;
+    const hopWalletInfos = actualHopCount > 0 ? generateRandomWallets(actualHopCount) : [];
     const hopWallets = hopWalletInfos.map(info => createWallet(info.privateKey, provider));
     const sellAmountWei = ethers.parseUnits(truncateDecimals(sellAmount, tokenDecimals), tokenDecimals);
-    // ✅ 修复：获取卖出报价，基于预估的 OKB 输出计算利润
+    // 获取卖出报价
     const estimatedOkbOut = await quoteSellOutput(sellAmountWei, tokenAddress, tradeType, fee, config?.rpcUrl);
-    // 使用双边费率计算利润（换手 = 卖 + 买）
+    // 计算利润和买入金额
     const profitAmount = estimatedOkbOut > 0n
-        ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true) // isDoubleMode = true
+        ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true)
         : 0n;
     const profitRecipient = getProfitRecipient(config);
+    const totalBuyAmountAfterProfit = estimatedOkbOut > profitAmount
+        ? estimatedOkbOut - profitAmount
+        : 0n;
+    const modeLabel = useFundUtilization ? '资金利用率' : '普通';
+    console.log(`[Bundle Batch Swap] 模式: ${modeLabel}`);
     console.log(`[Bundle Batch Swap] 卖出数量: ${sellAmount} Token`);
     console.log(`[Bundle Batch Swap] 预估获得: ${ethers.formatEther(estimatedOkbOut)} OKB`);
     console.log(`[Bundle Batch Swap] 利润: ${ethers.formatEther(profitAmount)} OKB (userType=${userType})`);
-    // ✅ FLAP 模式需要有效的报价（不能使用 0n 作为买入金额）
-    if (tradeType === 'FLAP' && estimatedOkbOut <= 0n) {
+    console.log(`[Bundle Batch Swap] 买入金额: ${ethers.formatEther(totalBuyAmountAfterProfit)} OKB`);
+    // 验证报价
+    if (tradeType === 'FLAP' && totalBuyAmountAfterProfit <= 0n) {
         throw new Error('FLAP 内盘模式需要有效的报价，请检查代币地址或稍后重试');
     }
     // ========================================
-    // 并行获取所有异步数据
+    // 并行获取数据
     // ========================================
     const addressesToQuery = [sellerWallet.address, ...buyerWallets.map(w => w.address)];
     const [nonces, feeData, ...buyerBalances] = await Promise.all([
         batchGetNonces(addressesToQuery, provider),
         provider.getFeeData(),
-        // 获取所有买家的 OKB 余额（普通模式下买家用自己的钱）
         ...buyerWallets.map(w => provider.getBalance(w.address)),
     ]);
     const sellerNonce = nonces[0];
     const buyerNonces = nonces.slice(1);
-    console.log(`[Bundle Batch Swap] 买家余额:`, buyerBalances.map(b => ethers.formatEther(b)));
+    // 普通模式验证：买家需要预存足够的 OKB
+    if (!useFundUtilization && tradeType === 'FLAP') {
+        const totalBuyerBalance = buyerBalances.reduce((sum, b) => sum + BigInt(b.toString()), 0n);
+        if (totalBuyerBalance < totalBuyAmountAfterProfit) {
+            throw new Error(`普通模式需要买家钱包总余额足够，需要 ${ethers.formatEther(totalBuyAmountAfterProfit)}，当前总计 ${ethers.formatEther(totalBuyerBalance)}`);
+        }
+    }
     // ========================================
-    // 同步构建调用
+    // 签署授权
     // ========================================
-    const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
-    const portalInterface = new ethers.Interface(FLAP_PORTAL_ABI);
-    const calls = [];
+    const authPromises = [];
+    authPromises.push(signAuthorization(sellerWallet, delegateAddress, BigInt(sellerNonce + 1)));
+    for (let i = 0; i < buyerWallets.length; i++) {
+        authPromises.push(signAuthorization(buyerWallets[i], delegateAddress, BigInt(buyerNonces[i])));
+    }
+    // 中间钱包授权（资金利用率模式）
+    for (const hopWallet of hopWallets) {
+        authPromises.push(signAuthorization(hopWallet, delegateAddress, 0n));
+    }
+    const authorizations = await Promise.all(authPromises);
     // ========================================
-    // ✅ 修复：普通换手模式逻辑（一卖多买）
-    // 1. 卖家卖出代币 → OKB 留在卖家账户
-    // 2. 所有买家用自己预存的 OKB 买入代币
-    // 3. 利润从第一个买家的 OKB 中扣除
+    // 构建调用
     // ========================================
-    // 1. 卖家卖出（OKB 留在卖家账户，不转给买家）
-    const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
-    calls.push(sellCall);
-    // 2. 利润刮取（从第一个买家扣除，在买入之前）
-    if (profitAmount > 0n) {
-        calls.push({
-            target: buyerWallets[0].address,
-            allowFailure: false,
-            value: 0n,
-            callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
-        });
-    }
-    // ✅ 3. 计算每个买家的买入金额（普通模式：买家用自己的 OKB）
-    // FLAP 模式需要使用买家的实际余额
+    const calls = [];
+    // 计算每个买家的买入金额
     let buyAmountsPerBuyer;
     if (tradeType === 'FLAP') {
-        // FLAP 模式：使用买家的实际 OKB 余额（第一个买家扣除利润）
-        buyAmountsPerBuyer = buyerBalances.map((balance, i) => {
-            const b = BigInt(balance.toString());
-            // 第一个买家需要扣除利润
-            return i === 0 ? (b > profitAmount ? b - profitAmount : 0n) : b;
-        });
-        console.log(`[bundleBatchSwap] FLAP 模式，买家买入金额:`, buyAmountsPerBuyer.map(a => ethers.formatEther(a)));
+        if (buyerWallets.length === 1) {
+            buyAmountsPerBuyer = [totalBuyAmountAfterProfit];
+        }
+        else if (buyerRatios && buyerRatios.length === buyerWallets.length) {
+            let allocated = 0n;
+            buyAmountsPerBuyer = buyerRatios.map((ratio, i) => {
+                const amount = (totalBuyAmountAfterProfit * BigInt(Math.round(ratio * 10000))) / 10000n;
+                if (i === buyerRatios.length - 1) {
+                    return totalBuyAmountAfterProfit - allocated;
+                }
+                allocated += amount;
+                return amount;
+            });
+        }
+        else {
+            const avgAmount = totalBuyAmountAfterProfit / BigInt(buyerWallets.length);
+            const remainder = totalBuyAmountAfterProfit % BigInt(buyerWallets.length);
+            buyAmountsPerBuyer = buyerWallets.map((_, i) => i === buyerWallets.length - 1 ? avgAmount + remainder : avgAmount);
+        }
     }
     else {
-        // V2/V3 模式：使用 0n，合约自动使用全部余额
         buyAmountsPerBuyer = buyerWallets.map(() => 0n);
     }
-    // 4. 所有买家买入（使用自己预存的 OKB）
-    for (let i = 0; i < buyerWallets.length; i++) {
-        const buyCall = buildBuyCallInternal(buyerWallets[i], buyAmountsPerBuyer[i], tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
-        calls.push(buyCall);
+    if (useFundUtilization) {
+        // ========================================
+        // ✅ 资金利用率模式（一卖多买）
+        // 1. 卖家卖出代币 → 获得 OKB
+        // 2. 利润从卖家 OKB 中扣除
+        // 3. OKB 多跳转账 → 分配给各买家
+        // 4. 各买家用收到的 OKB 买入
+        // ========================================
+        console.log(`[Bundle Batch Swap] 资金利用率模式，hopCount=${actualHopCount}`);
+        // 1. 卖家卖出
+        const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(sellCall);
+        // 2. 利润刮取（从卖家余额扣除）
+        if (profitAmount > 0n) {
+            calls.push({
+                target: sellerWallet.address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
+            });
+        }
+        // 3. OKB 多跳转账给第一个买家
+        const firstRecipient = hopWallets.length > 0 ? hopWallets[0].address : buyerWallets[0].address;
+        // 卖家 → 第一个接收者（转全部余额）
+        calls.push({
+            target: sellerWallet.address,
+            allowFailure: false,
+            value: 0n,
+            callData: delegateInterface.encodeFunctionData('transferTo', [firstRecipient]),
+        });
+        // 中间钱包之间转账
+        for (let i = 0; i < hopWallets.length; i++) {
+            const nextRecipient = i < hopWallets.length - 1 ? hopWallets[i + 1].address : buyerWallets[0].address;
+            calls.push({
+                target: hopWallets[i].address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferTo', [nextRecipient]),
+            });
+        }
+        // 第一个买家分配给其他买家
+        for (let i = 1; i < buyerWallets.length; i++) {
+            calls.push({
+                target: buyerWallets[0].address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferAmount', [buyerWallets[i].address, buyAmountsPerBuyer[i]]),
+            });
+        }
+        // 4. 所有买家买入
+        for (let i = 0; i < buyerWallets.length; i++) {
+            const buyCall = buildBuyCallInternal(buyerWallets[i], buyAmountsPerBuyer[i], tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+            calls.push(buyCall);
+        }
     }
-    // ========================================
-    // 同步签署授权（只需要卖家和买家，不需要 hop wallets）
-    // ========================================
-    const authPromises = [];
-    // 卖家授权（交易发起者，nonce +1）
-    authPromises.push(signAuthorization(sellerWallet, delegateAddress, BigInt(sellerNonce + 1)));
-    // 买家授权
-    for (let i = 0; i < buyerWallets.length; i++) {
-        authPromises.push(signAuthorization(buyerWallets[i], delegateAddress, BigInt(buyerNonces[i])));
+    else {
+        // ========================================
+        // ✅ 普通模式（一卖多买）
+        // 1. 卖家卖出代币 → OKB 留在卖家账户
+        // 2. 利润从第一个买家 OKB 中扣除
+        // 3. 各买家用自己预存的 OKB 买入
+        // ========================================
+        console.log(`[Bundle Batch Swap] 普通模式`);
+        // 1. 卖家卖出（OKB 留在卖家账户）
+        const sellCall = buildSellCallWithAmountInternal(sellerWallet, sellAmountWei, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+        calls.push(sellCall);
+        // 2. 利润刮取（从第一个买家余额扣除）
+        if (profitAmount > 0n) {
+            calls.push({
+                target: buyerWallets[0].address,
+                allowFailure: false,
+                value: 0n,
+                callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
+            });
+        }
+        // 3. 所有买家买入（使用自己预存的 OKB）
+        for (let i = 0; i < buyerWallets.length; i++) {
+            const buyCall = buildBuyCallInternal(buyerWallets[i], buyAmountsPerBuyer[i], tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
+            calls.push(buyCall);
+        }
     }
-    const authorizations = await Promise.all(authPromises);
     // ========================================
-    // 同步构建交易
+    // 构建交易
     // ========================================
-    const signedTransaction = buildEIP7702TransactionSync(sellerWallet, authorizations, calls, 0n, // ✅ 利润使用 transferAmount 从卖家余额转账，不需要通过 msg.value 传递
-    sellerNonce, feeData, config);
+    const signedTransaction = buildEIP7702TransactionSync(sellerWallet, authorizations, calls, 0n, sellerNonce, feeData, config);
     return {
         signedTransaction,
         hopWallets: hopWalletInfos,
@@ -524,11 +660,12 @@ export async function bundleBatchSwap(params) {
             sellerAddress: sellerWallet.address,
             buyerAddresses: buyerWallets.map(w => w.address),
             sellAmount: ethers.formatUnits(sellAmountWei, tokenDecimals),
-            estimatedOkbOut: ethers.formatEther(estimatedOkbOut), // ✅ 预估卖出所得 OKB
-            estimatedBuyAmount: '0',
-            profitAmount: ethers.formatEther(profitAmount), // ✅ 利润是 OKB
+            estimatedOkbOut: ethers.formatEther(estimatedOkbOut),
+            estimatedBuyAmount: ethers.formatEther(totalBuyAmountAfterProfit),
+            profitAmount: ethers.formatEther(profitAmount),
             profitRecipient,
             userType,
+            useFundUtilization,
         },
     };
 }

package/dist/eip7702/xlayer/multi-hop-transfer.d.ts

@@ -21,8 +21,10 @@ export interface TransferResult {
     metadata: Record<string, unknown>;
 }
 export interface DisperseParams {
-    /** 主钱包私钥（发起者，支付 gas） */
+    /** 资金来源钱包私钥（Token/OKB 从这个钱包转出） */
     mainPrivateKey: string;
+    /** Payer 钱包私钥（可选，用于支付 gas；不传则使用 mainPrivateKey） */
+    payerPrivateKey?: string;
     /** 接收者地址列表 */
     recipients: string[];
     /** 每个接收者的金额 */

package/dist/eip7702/xlayer/multi-hop-transfer.js

@@ -101,16 +101,23 @@ async function quoteTokenToOkb(tokenAddress, tokenAmount, rpcUrl) {
  * });
  */
 export async function disperse(params) {
-    const { mainPrivateKey, recipients, amounts, tokenAddress, tokenDecimals = 18, hopCount = 0, userType, config, } = params;
+    const { mainPrivateKey, payerPrivateKey, recipients, amounts, tokenAddress, tokenDecimals = 18, hopCount = 0, userType, config, } = params;
     if (recipients.length !== amounts.length) {
         throw new Error('recipients 和 amounts 长度必须相同');
     }
     const provider = getCachedProvider(config?.rpcUrl);
     const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
     const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
+    // ✅ mainWallet: 资金来源（Token/OKB 从这里转出）
     const mainWallet = createWallet(mainPrivateKey, provider);
     const isNative = !tokenAddress;
     const profitRecipient = getProfitRecipient(config);
+    // ✅ 支持单独的 Payer 钱包（用于支付 gas）
+    const hasSeparatePayer = payerPrivateKey && payerPrivateKey !== mainPrivateKey;
+    const payerWallet = hasSeparatePayer ? createWallet(payerPrivateKey, provider) : null;
+    const txSender = payerWallet ?? mainWallet; // 交易发起者
+    console.log(`[disperse] 资金钱包: ${mainWallet.address}`);
+    console.log(`[disperse] Gas Payer: ${txSender.address}${hasSeparatePayer ? ' (独立 Payer)' : ''}`);
     // ✅ 为每个接收者生成独立的中间钱包链
     // 每个接收者有自己的 hopCount 个中间钱包
     const allHopWalletInfos = [];
@@ -145,23 +152,28 @@ export async function disperse(params) {
     // ========================================
     // 并行获取数据
     // ========================================
-    const [mainNonce, feeData] = await Promise.all([
-        provider.getTransactionCount(mainWallet.address, 'pending'),
+    const addressesToGetNonces = payerWallet
+        ? [payerWallet.address, mainWallet.address]
+        : [mainWallet.address];
+    const [allNoncesResult, feeData] = await Promise.all([
+        batchGetNonces(addressesToGetNonces, provider),
         provider.getFeeData(),
     ]);
+    const payerNonce = payerWallet ? allNoncesResult[0] : allNoncesResult[0];
+    const mainNonce = payerWallet ? allNoncesResult[1] : allNoncesResult[0];
     // ========================================
     // 同步签署授权（已有 nonce）
     // ========================================
-    // 主钱包 + 所有中间钱包
-    const allWallets = [mainWallet];
-    const allNonces = [mainNonce];
+    // ✅ 如果有 Payer，需要为 Payer 和 mainWallet 都生成授权
+    const allWallets = payerWallet ? [payerWallet, mainWallet] : [mainWallet];
+    const allNonces = payerWallet ? [payerNonce, mainNonce] : [mainNonce];
     for (const hopWallets of allHopWallets) {
         for (const hopWallet of hopWallets) {
             allWallets.push(hopWallet);
             allNonces.push(0);
         }
     }
-    const authorizations = signAuthorizationsWithNonces(allWallets, allNonces, delegateAddress, 0 // mainWallet 是交易发起者
+    const authorizations = signAuthorizationsWithNonces(allWallets, allNonces, delegateAddress, 0 // txSender（Payer 或 mainWallet）是交易发起者
     );
     // ========================================
     // 同步构建调用
@@ -176,12 +188,24 @@ export async function disperse(params) {
             // 直接分发：主钱包 → 接收者
             // ========================================
             if (isNative) {
-                calls.push({
-                    target: mainWallet.address,
-                    allowFailure: false,
-                    value: amtWei,
-                    callData: delegateInterface.encodeFunctionData('transferTo', [recipient]),
-                });
+                // ✅ Payer 模式：使用 transferAmount（从 mainWallet 余额转出）
+                // ✅ 非 Payer 模式：使用 transferTo（从 msg.value 转出）
+                if (payerWallet) {
+                    calls.push({
+                        target: mainWallet.address,
+                        allowFailure: false,
+                        value: 0n,
+                        callData: delegateInterface.encodeFunctionData('transferAmount', [recipient, amtWei]),
+                    });
+                }
+                else {
+                    calls.push({
+                        target: mainWallet.address,
+                        allowFailure: false,
+                        value: amtWei,
+                        callData: delegateInterface.encodeFunctionData('transferTo', [recipient]),
+                    });
+                }
             }
             else {
                 calls.push({
@@ -204,13 +228,24 @@ export async function disperse(params) {
             const lastHop = hopWallets[hopWallets.length - 1];
             if (isNative) {
                 // 主钱包 → 第一个中间钱包
-                calls.push({
-                    target: mainWallet.address,
-                    allowFailure: false,
-                    value: amtWei,
-                    callData: delegateInterface.encodeFunctionData('transferTo', [firstHop.address]),
-                });
-                // 中间钱包之间转账
+                // ✅ Payer 模式：使用 transferAmount（从 mainWallet 余额转出）
+                if (payerWallet) {
+                    calls.push({
+                        target: mainWallet.address,
+                        allowFailure: false,
+                        value: 0n,
+                        callData: delegateInterface.encodeFunctionData('transferAmount', [firstHop.address, amtWei]),
+                    });
+                }
+                else {
+                    calls.push({
+                        target: mainWallet.address,
+                        allowFailure: false,
+                        value: amtWei,
+                        callData: delegateInterface.encodeFunctionData('transferTo', [firstHop.address]),
+                    });
+                }
+                // 中间钱包之间转账（使用全部余额）
                 for (let j = 0; j < hopWallets.length - 1; j++) {
                     calls.push({
                         target: hopWallets[j].address,
@@ -219,7 +254,7 @@ export async function disperse(params) {
                         callData: delegateInterface.encodeFunctionData('transferTo', [hopWallets[j + 1].address]),
                     });
                 }
-                // 最后一个中间钱包 → 接收者
+                // 最后一个中间钱包 → 接收者（使用全部余额）
                 calls.push({
                     target: lastHop.address,
                     allowFailure: false,
@@ -280,15 +315,20 @@ export async function disperse(params) {
     // ========================================
     // 构建交易
     // ========================================
-    const totalValue = isNative ? totalAmount : 0n;
-    const signedTransaction = buildEIP7702TransactionSync(mainWallet, authorizations, calls, totalValue, mainNonce, feeData, config);
+    // ✅ Payer 模式下 value 为 0（资金从 mainWallet 转出，不是 Payer）
+    // 无 Payer 时，原生币分发需要传递 value（资金从 txSender 转出）
+    const totalValue = (isNative && !payerWallet) ? totalAmount : 0n;
+    const signedTransaction = buildEIP7702TransactionSync(txSender, // ✅ 使用 txSender（Payer 或 mainWallet）发起交易
+    authorizations, calls, totalValue, payerNonce, // ✅ 使用 txSender 的 nonce
+    feeData, config);
     // ✅ 返回所有中间钱包（扁平化）
     const flatHopWallets = allHopWalletInfos.flat();
     return {
         signedTransaction,
         hopWallets: flatHopWallets.length > 0 ? flatHopWallets : undefined,
         metadata: {
-            senderAddress: mainWallet.address,
+            senderAddress: mainWallet.address, // 资金来源
+            payerAddress: txSender.address, // Gas 支付者
             recipientCount: recipients.length,
             totalAmount: isNative ? ethers.formatEther(totalAmount) : ethers.formatUnits(totalAmount, tokenDecimals),
             profitAmount: ethers.formatEther(profitAmountOkb), // ✅ 以 OKB 计

package/dist/eip7702/xlayer/types.d.ts

@@ -204,6 +204,8 @@ export interface BundleSwapResult {
         profitRecipient?: string;
         /** 用户类型 */
         userType?: string;
+        /** 是否使用资金利用率模式 */
+        useFundUtilization?: boolean;
     };
 }
 export interface MultiHopTransferParams {

package/package.json

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