four-flap-meme-sdk 1.7.61 → 1.7.62

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

@@ -315,9 +315,14 @@ export async function bundleSwap(params) {
         ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true) // isDoubleMode = true
         : 0n;
     const profitRecipient = getProfitRecipient(config);
+    // ✅ 计算买入金额：基于卖家卖出得到的 OKB（不是买家全部余额）
+    const buyAmountAfterProfit = estimatedOkbOut > profitAmount
+        ? estimatedOkbOut - profitAmount
+        : 0n;
     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（基于卖出所得）`);
     // ========================================
     // 并行获取所有异步数据
     // ========================================
@@ -326,12 +331,21 @@ export async function bundleSwap(params) {
         batchGetNonces([sellerWallet.address, buyerWallet.address], provider),
         // 获取 gas 费用数据
         provider.getFeeData(),
-        // 获取买家的 OKB 余额（普通模式下买家用自己的钱）
+        // 获取买家的 OKB 余额（验证是否足够）
         provider.getBalance(buyerWallet.address),
     ]);
     const sellerNonce = nonces[0];
     const buyerNonce = nonces[1];
     console.log(`[Bundle Swap] 买家 OKB 余额: ${ethers.formatEther(buyerBalance)} OKB`);
+    // ✅ FLAP 模式需要买家有足够的 OKB（至少等于卖家卖出得到的 OKB）
+    if (tradeType === 'FLAP') {
+        if (buyAmountAfterProfit <= 0n) {
+            throw new Error('FLAP 内盘模式需要有效的报价，请检查代币地址或稍后重试');
+        }
+        if (buyerBalance < buyAmountAfterProfit) {
+            throw new Error(`FLAP 内盘模式需要买家钱包有足够的 OKB，需要 ${ethers.formatEther(buyAmountAfterProfit)}，当前 ${ethers.formatEther(buyerBalance)}`);
+        }
+    }
     // ========================================
     // 同步签署授权（只需要卖家和买家，不需要 hop wallets）
     // ========================================
@@ -342,22 +356,11 @@ export async function bundleSwap(params) {
     authorizations.push(signAuthorization(buyerWallet, delegateAddress, BigInt(buyerNonce)));
     // 等待所有授权签名完成
     const resolvedAuthorizations = await Promise.all(authorizations);
-    // ========================================
-    // 同步构建调用
-    // ========================================
-    // ✅ 计算买入金额（普通模式：买家用自己的 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 calls = [];
     // ========================================
     // ✅ 普通换手模式逻辑
     // 1. 卖家卖出代币 → OKB 留在卖家账户
-    // 2. 买家用自己预存的 OKB 买入代币
+    // 2. 买家用自己预存的 OKB 买入代币（金额 = 卖家卖出所得，不是全部余额）
     // 3. 利润从买家的 OKB 中扣除
     // ========================================
     // 1. 卖家卖出（OKB 留在卖家账户，不转给买家）
@@ -373,8 +376,10 @@ export async function bundleSwap(params) {
         });
     }
     // 3. 买家用自己预存的 OKB 买入
-    // ✅ FLAP 模式使用买家实际余额（扣除利润后），V2/V3 模式使用 0n（合约自动使用全部余额）
-    const buyAmountForCall = tradeType === 'FLAP' ? buyerAvailable : 0n;
+    // ✅ 关键修复：买入金额 = 卖家卖出所得（扣除利润），而不是买家全部余额
+    // FLAP 模式必须指定精确金额，V2/V3 使用 0n（合约自动使用全部余额）
+    const buyAmountForCall = tradeType === 'FLAP' ? buyAmountAfterProfit : 0n;
+    console.log(`[Bundle Swap] 实际买入调用金额: ${ethers.formatEther(buyAmountForCall)} OKB`);
     const buyCall = buildBuyCallInternal(buyerWallet, buyAmountForCall, tokenAddress, tradeType, actualRouter, fee, delegateInterface, portalInterface);
     calls.push(buyCall);
     // ========================================
@@ -436,11 +441,16 @@ export async function bundleBatchSwap(params) {
         ? calculateProfitAmountByUserType(estimatedOkbOut, userType, true) // isDoubleMode = true
         : 0n;
     const profitRecipient = getProfitRecipient(config);
+    // ✅ 计算总买入金额：基于卖家卖出得到的 OKB（不是买家全部余额）
+    const totalBuyAmountAfterProfit = estimatedOkbOut > profitAmount
+        ? estimatedOkbOut - profitAmount
+        : 0n;
     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})`);
+    console.log(`[Bundle Batch Swap] 买家总应买入: ${ethers.formatEther(totalBuyAmountAfterProfit)} OKB（基于卖出所得）`);
     // ✅ FLAP 模式需要有效的报价（不能使用 0n 作为买入金额）
-    if (tradeType === 'FLAP' && estimatedOkbOut <= 0n) {
+    if (tradeType === 'FLAP' && totalBuyAmountAfterProfit <= 0n) {
         throw new Error('FLAP 内盘模式需要有效的报价，请检查代币地址或稍后重试');
     }
     // ========================================
@@ -450,12 +460,19 @@ export async function bundleBatchSwap(params) {
     const [nonces, feeData, ...buyerBalances] = await Promise.all([
         batchGetNonces(addressesToQuery, provider),
         provider.getFeeData(),
-        // 获取所有买家的 OKB 余额（普通模式下买家用自己的钱）
+        // 获取所有买家的 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)));
+    // ✅ FLAP 模式验证：买家总余额必须足够
+    if (tradeType === 'FLAP') {
+        const totalBuyerBalance = buyerBalances.reduce((sum, b) => sum + BigInt(b.toString()), 0n);
+        if (totalBuyerBalance < totalBuyAmountAfterProfit) {
+            throw new Error(`FLAP 内盘模式需要买家钱包总余额足够，需要 ${ethers.formatEther(totalBuyAmountAfterProfit)}，当前总计 ${ethers.formatEther(totalBuyerBalance)}`);
+        }
+    }
     // ========================================
     // 同步构建调用
     // ========================================
@@ -480,17 +497,37 @@ export async function bundleBatchSwap(params) {
             callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
         });
     }
-    // ✅ 3. 计算每个买家的买入金额（普通模式：买家用自己的 OKB）
-    // FLAP 模式需要使用买家的实际余额
+    // ✅ 3. 计算每个买家的买入金额
+    // 关键修复：买入金额 = 卖家卖出所得（按比例分配），而不是买家全部余额
     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)));
+        // FLAP 模式：按比例分配卖家卖出所得的 OKB
+        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) => {
+                // 最后一个买家分配剩余
+                return i === buyerWallets.length - 1 ? avgAmount + remainder : avgAmount;
+            });
+        }
+        console.log(`[bundleBatchSwap] FLAP 模式，买家买入金额（基于卖出所得）:`, buyAmountsPerBuyer.map(a => ethers.formatEther(a)));
     }
     else {
         // V2/V3 模式：使用 0n，合约自动使用全部余额

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/package.json

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