four-flap-meme-sdk 1.2.87 → 1.2.88

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

@@ -29,6 +29,7 @@ export interface FlapSwapConfig extends CommonBundleConfig {
     waitTimeoutMs?: number;
     skipApprovalCheck?: boolean;
 }
+import { FundRoutingConfig } from './types.js';
 export interface FlapBundleSwapSignParams {
     chain: FlapChain;
     sellerPrivateKey: string;
@@ -37,6 +38,8 @@ export interface FlapBundleSwapSignParams {
     buyerPrivateKey: string;
     tokenAddress: string;
     config: FlapSwapSignConfig;
+    /** 资金路由配置 */
+    routing?: FundRoutingConfig;
 }
 export interface FlapBundleSwapParams {
     chain: FlapChain;
@@ -57,6 +60,11 @@ export type FlapSwapResult = {
         buyAmount: string;
         hasApproval?: boolean;
         profitAmount?: string;
+        routing?: {
+            mainAddress: string;
+            hopAddresses: string[];
+            totalHops: number;
+        };
     };
 };
 /**

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

@@ -56,11 +56,15 @@ function getNativeTokenName(chain) {
  * Flap内盘捆绑换手
  */
 export async function flapBundleSwapMerkle(params) {
-    const { chain, sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKey, tokenAddress, config } = params;
+    const { chain, sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKey, tokenAddress, config, routing // ✅ 新增：路由配置
+     } = params;
     const chainContext = createChainContext(chain, config);
     const seller = new Wallet(sellerPrivateKey, chainContext.provider);
+    // 如果有 routing，买家是 routing 链路的终点；否则是普通 buyer
+    // 注意：如果是路由模式，买家不需要预先有 BNB，资金从 seller 来
     const buyer = new Wallet(buyerPrivateKey, chainContext.provider);
     const { amount: sellAmountWei, decimals } = await calculateSellAmount(chainContext.provider, tokenAddress, seller.address, sellAmount, sellPercentage);
+    // ... (省略部分: approval) ...
     const approvalTx = config.skipApprovalCheck
         ? null
         : await buildApprovalTransaction({
@@ -82,14 +86,93 @@ export async function flapBundleSwapMerkle(params) {
         slippageBps: config.slippageBps,
         skipQuoteOnError: config.skipQuoteOnError
     });
-    const buyerNeed = await calculateBuyerNeed({
-        buyer,
-        quotedNative: quote.quotedNative,
-        reserveGasEth: config.reserveGasETH,
-        slippageBps: config.slippageBps,
-        nativeToken: chainContext.nativeToken
-    });
+    const finalGasLimit = getGasLimit(config);
+    const gasPrice = await getOptimizedGasPrice(chainContext.provider, getGasPriceConfig(config));
+    const txType = getTxType(config);
+    const priorityFee = gasPrice / 10n === 0n ? 1n : gasPrice / 10n;
     const profitAmount = calculateProfitAmount(quote.quotedNative);
+    const extractProfit = profitAmount > 0n;
+    // ✅ 核心逻辑分支：是否有资金路由
+    let routeTxs = [];
+    let buyerAvailableFunds = 0n;
+    let noncePlan;
+    let hopInfo = undefined;
+    const nonceManager = new NonceManager(chainContext.provider);
+    if (routing) {
+        // === 路由模式 ===
+        // 1. Seller Sell -> BNB
+        // 2. Seller Transfer (BNB - Gas - Profit) -> Main Wallet
+        // 3. Main -> Hops -> Buyer
+        // 4. Buyer Buy
+        console.log('🔄 启用资金路由模式...');
+        // 计算 Seller 卖出后剩余可转移金额
+        const sellGasCost = finalGasLimit * gasPrice; // 卖出交易 Gas
+        const transferGasCost = 21000n * gasPrice; // 每一跳 Gas
+        // 预估卖出所得 (保守估计，扣除滑点)
+        const safeSlippage = Math.max(0, Math.min(5000, config.slippageBps ?? 100));
+        const estimatedSellOutput = (quote.quotedNative * BigInt(10000 - safeSlippage)) / 10000n;
+        // Seller 需保留的 Gas (卖出 + 转账 + 利润(如有))
+        const sellerTxCount = countTruthy([approvalTx, true, true, profitAmount > 0n]); // Approve?, Sell, Transfer, Profit?
+        const sellerTotalGas = BigInt(sellerTxCount) * sellGasCost; // 简化估算，都按大 Gas 算比较安全，或者精确计算
+        // 实际上 Seller 转账给 Main 的金额 = 卖出所得 - (卖出Gas + 利润)
+        // 注意：这里假设 Seller 账户里有额外的 BNB 支付 Gas，或者从卖出所得里扣
+        // 为了稳健，我们假设必须从卖出所得里扣除后续步骤的 Gas
+        let transferAmount = estimatedSellOutput - profitAmount;
+        // 如果 Seller 余额很低，可能需要扣除 Gas。为了简化，假设 Seller 有少量 BNB 启动。
+        // 这里我们只扣除利润。
+        if (transferAmount <= 0n) {
+            throw new Error(`卖出金额不足以支付利润和 Gas: ${ethers.formatEther(estimatedSellOutput)} BNB`);
+        }
+        // 构建路由链路
+        const routeResult = await buildFundingRoute({
+            routing,
+            initialAmount: transferAmount,
+            seller,
+            buyerAddress: buyer.address,
+            gasPrice,
+            chainId: chainContext.chainId,
+            txType,
+            nonceManager
+        });
+        routeTxs = routeResult.signedTxs;
+        buyerAvailableFunds = routeResult.finalAmount;
+        hopInfo = routeResult.hopInfo;
+        console.log(`💸 资金路由: 初始 ${ethers.formatEther(transferAmount)} -> 最终 ${ethers.formatEther(buyerAvailableFunds)}`);
+        // 重新规划 Nonce (Seller 和 Buyer 的部分已经由 buildFundingRoute 处理或者需要重新对齐)
+        // buildFundingRoute 处理了 Main 和 Hops 的 nonce。
+        // Seller 的 nonce 需要在这里处理：Approve -> Sell -> Transfer -> Profit
+        // Buyer 的 nonce: Buy
+        // 由于 buildFundingRoute 内部使用了 seller 签名了一笔转账，我们需要确保 nonce 顺序
+        // 实际上 buildFundingRoute 应该只负责 Main -> Buyer，
+        // Seller -> Main 的转账应该在这里构建，以便和 Sell 交易排序。
+        // 修正策略：
+        // routeResult 只包含 Main -> ... -> Buyer 的交易
+        // 这里负责:
+        // 1. Seller Sell
+        // 2. Seller -> Main
+        // 3. ...Route Txs...
+        // 4. Buyer Buy
+    }
+    else {
+        // === 普通模式 ===
+        const buyerNeed = await calculateBuyerNeed({
+            buyer,
+            quotedNative: quote.quotedNative,
+            reserveGasEth: config.reserveGasETH,
+            slippageBps: config.slippageBps,
+            nativeToken: chainContext.nativeToken
+        });
+        await validateBalances({
+            buyerNeed,
+            buyerAddress: buyer.address,
+            portalGasCost: finalGasLimit * gasPrice,
+            provider: chainContext.provider,
+            chainContext,
+            seller
+        });
+        buyerAvailableFunds = buyerNeed.maxBuyerValue;
+    }
+    // ... (构建交易对象: sellUnsigned, buyUnsigned) ...
     const sellUnsigned = await portalSeller.swapExactInput.populateTransaction({
         inputToken: tokenAddress,
         outputToken: ZERO_ADDRESS,
@@ -100,53 +183,121 @@ export async function flapBundleSwapMerkle(params) {
     const buyUnsigned = await portalBuyer.swapExactInput.populateTransaction({
         inputToken: ZERO_ADDRESS,
         outputToken: tokenAddress,
-        inputAmount: buyerNeed.maxBuyerValue,
+        inputAmount: buyerAvailableFunds, // ✅ 使用计算出的可用资金
         minOutputAmount: 0,
         permitData: '0x'
-    }, { value: buyerNeed.maxBuyerValue });
-    const finalGasLimit = getGasLimit(config);
-    const gasPrice = await getOptimizedGasPrice(chainContext.provider, getGasPriceConfig(config));
-    const txType = getTxType(config);
-    const priorityFee = gasPrice / 10n === 0n ? 1n : gasPrice / 10n;
-    await validateBalances({
-        buyerNeed,
-        buyerAddress: buyer.address,
-        portalGasCost: finalGasLimit * gasPrice,
-        provider: chainContext.provider,
-        chainContext,
-        seller
-    });
-    const nonceManager = new NonceManager(chainContext.provider);
-    const noncePlan = await planNonces({
-        seller,
-        buyer,
-        approvalExists: !!approvalTx,
-        extractProfit: profitAmount > 0n,
-        nonceManager
-    });
-    const sellTx = buildTransactionRequest(sellUnsigned, {
-        from: seller.address,
-        nonce: noncePlan.sellerNonce,
-        gasLimit: finalGasLimit,
-        gasPrice,
-        priorityFee,
-        chainId: chainContext.chainId,
-        txType
-    });
-    const buyTx = buildTransactionRequest(buyUnsigned, {
-        from: buyer.address,
-        nonce: noncePlan.buyerNonce,
-        gasLimit: finalGasLimit,
-        gasPrice,
-        priorityFee,
-        chainId: chainContext.chainId,
-        txType,
-        value: buyerNeed.maxBuyerValue
-    });
-    const [signedSell, signedBuy] = await Promise.all([
-        seller.signTransaction(sellTx),
-        buyer.signTransaction(buyTx)
-    ]);
+    }, { value: buyerAvailableFunds });
+    // ... (Nonce 规划) ...
+    // 如果是路由模式，Nonce 规划比较复杂，需要手动处理
+    let signedSell;
+    let signedBuy;
+    let sellerTransferTx = null;
+    if (routing) {
+        // 路由模式下的 Nonce 规划
+        // Seller: [Approve], Sell, TransferToMain, [Profit]
+        const sellerStartNonce = await nonceManager.getNextNonce(seller); // 获取当前 nonce，不做自增，后面手动加
+        let currentSellerNonce = sellerStartNonce;
+        // Approve (如果在上面已经构建了，nonce 可能是错的，因为上面还没用 nonceManager?)
+        // 上面的 buildApprovalTransaction 内部用了 nonceManager.getNextNonce(seller)
+        // 这会导致 nonce 错乱。
+        // 🛑 必须重构：buildApprovalTransaction 不应该内部签名，应该返回 Request 或者由外部管理 Nonce
+        // 为了不破坏现有结构太大，我们假设 buildApprovalTransaction 消耗了一个 Nonce。
+        // 如果 approvalTx 存在，nonceManager 已经记录了 seller 用过一个 nonce。
+        // Sell
+        currentSellerNonce = await nonceManager.getNextNonce(seller);
+        const sellTx = buildTransactionRequest(sellUnsigned, {
+            from: seller.address,
+            nonce: currentSellerNonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            priorityFee,
+            chainId: chainContext.chainId,
+            txType
+        });
+        signedSell = await seller.signTransaction(sellTx);
+        // Transfer to Main
+        const transferToMainNonce = await nonceManager.getNextNonce(seller);
+        const transferAmount = quote.quotedNative - profitAmount - (21000n * gasPrice); // 简单扣除 Gas
+        sellerTransferTx = await seller.signTransaction({
+            to: new Wallet(routing.mainPrivateKey).address,
+            value: transferAmount, // 这里是个预估值，必须保守
+            nonce: transferToMainNonce,
+            gasLimit: 21000n,
+            gasPrice,
+            chainId: chainContext.chainId,
+            type: txType
+        });
+        // Route Txs (Main -> ... -> Buyer)
+        // 这里重新调用 buildFundingRoute，它会处理 Main 和 Hops 的 nonce
+        const routeRes = await buildFundingRoute({
+            routing,
+            initialAmount: transferAmount,
+            seller, // 这里其实不需要 seller
+            buyerAddress: buyer.address,
+            gasPrice,
+            chainId: chainContext.chainId,
+            txType,
+            nonceManager
+        });
+        routeTxs = routeRes.signedTxs;
+        // 更新 Buyer 可用资金 (扣除链路 Gas)
+        buyerAvailableFunds = routeRes.finalAmount;
+        // 重新构建 Buy Tx (因为金额变了)
+        const buyUnsignedFinal = await portalBuyer.swapExactInput.populateTransaction({
+            inputToken: ZERO_ADDRESS,
+            outputToken: tokenAddress,
+            inputAmount: buyerAvailableFunds,
+            minOutputAmount: 0,
+            permitData: '0x'
+        }, { value: buyerAvailableFunds });
+        const buyerNonce = await nonceManager.getNextNonce(buyer);
+        const buyTx = buildTransactionRequest(buyUnsignedFinal, {
+            from: buyer.address,
+            nonce: buyerNonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            priorityFee,
+            chainId: chainContext.chainId,
+            txType,
+            value: buyerAvailableFunds
+        });
+        signedBuy = await buyer.signTransaction(buyTx);
+        noncePlan = { sellerNonce: currentSellerNonce, buyerNonce, profitNonce: extractProfit ? await nonceManager.getNextNonce(seller) : undefined };
+    }
+    else {
+        // 普通模式 (保持原样)
+        noncePlan = await planNonces({
+            seller,
+            buyer,
+            approvalExists: !!approvalTx,
+            extractProfit: profitAmount > 0n,
+            nonceManager
+        });
+        const sellTx = buildTransactionRequest(sellUnsigned, {
+            from: seller.address,
+            nonce: noncePlan.sellerNonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            priorityFee,
+            chainId: chainContext.chainId,
+            txType
+        });
+        const buyTx = buildTransactionRequest(buyUnsigned, {
+            from: buyer.address,
+            nonce: noncePlan.buyerNonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            priorityFee,
+            chainId: chainContext.chainId,
+            txType,
+            value: buyerAvailableFunds // ✅ 修复：使用 buyerAvailableFunds
+        });
+        [signedSell, signedBuy] = await Promise.all([
+            seller.signTransaction(sellTx),
+            buyer.signTransaction(buyTx)
+        ]);
+    }
+    // ... (Profit Tx) ...
     const profitTx = await buildProfitTransaction({
         seller,
         profitAmount,
@@ -159,7 +310,18 @@ export async function flapBundleSwapMerkle(params) {
     const allTransactions = [];
     if (approvalTx)
         allTransactions.push(approvalTx);
-    allTransactions.push(signedSell, signedBuy);
+    // ✅ 根据模式组装交易
+    if (routing && sellerTransferTx) {
+        // 路由模式: Sell -> SellerTransfer -> RouteTxs -> Buy
+        allTransactions.push(signedSell);
+        allTransactions.push(sellerTransferTx);
+        allTransactions.push(...routeTxs);
+        allTransactions.push(signedBuy);
+    }
+    else {
+        // 普通模式: Sell -> Buy
+        allTransactions.push(signedSell, signedBuy);
+    }
     if (profitTx)
         allTransactions.push(profitTx);
     return {
@@ -168,9 +330,108 @@ export async function flapBundleSwapMerkle(params) {
             sellerAddress: seller.address,
             buyerAddress: buyer.address,
             sellAmount: ethers.formatUnits(sellAmountWei, decimals),
-            buyAmount: ethers.formatEther(buyerNeed.maxBuyerValue),
+            buyAmount: ethers.formatEther(buyerAvailableFunds),
             hasApproval: !!approvalTx,
-            profitAmount: profitAmount > 0n ? ethers.formatEther(profitAmount) : undefined
+            profitAmount: profitAmount > 0n ? ethers.formatEther(profitAmount) : undefined,
+            // ✅ 路由元数据
+            routing: routing ? {
+                mainAddress: new Wallet(routing.mainPrivateKey).address,
+                hopAddresses: hopInfo?.addresses || [],
+                totalHops: hopInfo?.count || 0
+            } : undefined
+        }
+    };
+}
+async function buildFundingRoute({ routing, initialAmount, seller, buyerAddress, gasPrice, chainId, txType, nonceManager }) {
+    const mainWallet = new Wallet(routing.mainPrivateKey, seller.provider);
+    const signedTxs = [];
+    // 每笔转账消耗 Gas (21000 * gasPrice)
+    const transferGasCost = 21000n * gasPrice;
+    let currentAmount = initialAmount;
+    let currentFrom = mainWallet;
+    let currentNonce = await nonceManager.getNextNonce(mainWallet);
+    const hops = routing.hops || { count: 0 };
+    const hopCount = hops.count || (hops.privateKeys?.length ?? 0);
+    const hopAddresses = [];
+    // 如果有中间跳板
+    if (hopCount > 0) {
+        const hopWallets = [];
+        // 生成或使用指定的跳板钱包
+        for (let i = 0; i < hopCount; i++) {
+            let wallet;
+            if (hops.privateKeys && hops.privateKeys[i]) {
+                wallet = new Wallet(hops.privateKeys[i], seller.provider);
+            }
+            else {
+                const randomWallet = Wallet.createRandom(seller.provider);
+                wallet = new Wallet(randomWallet.privateKey, seller.provider); // ✅ 通过私钥重新创建 Wallet 实例以匹配类型
+            }
+            hopWallets.push(wallet);
+            hopAddresses.push(wallet.address);
+        }
+        // 1. Main -> Hop 1
+        // 需要确保 currentAmount 足够扣除 Gas
+        if (currentAmount <= transferGasCost)
+            throw new Error('资金不足以支付路由 Gas');
+        let sendAmount = currentAmount - transferGasCost; // 扣除本步 Gas
+        // 注意：如果是新生成的钱包，需要从上一步收到的钱里扣除下一步的 Gas
+        // 实际上每一跳的转账金额应该是：收到金额 - (下一步转账的 Gas)
+        // 最后一跳给 Buyer 的金额是剩余全部
+        // Main -> Hop1
+        signedTxs.push(await currentFrom.signTransaction({
+            to: hopWallets[0].address,
+            value: sendAmount,
+            nonce: currentNonce,
+            gasLimit: 21000n,
+            gasPrice,
+            chainId,
+            type: txType
+        }));
+        currentAmount = sendAmount;
+        // Hop i -> Hop i+1 (or Buyer)
+        for (let i = 0; i < hopCount; i++) {
+            const isLastHop = i === hopCount - 1;
+            const targetAddress = isLastHop ? buyerAddress : hopWallets[i + 1].address;
+            const fromWallet = hopWallets[i];
+            if (currentAmount <= transferGasCost)
+                throw new Error('路由过程中资金耗尽');
+            sendAmount = currentAmount - transferGasCost;
+            const nonce = await nonceManager.getNextNonce(fromWallet);
+            signedTxs.push(await fromWallet.signTransaction({
+                to: targetAddress,
+                value: sendAmount,
+                nonce,
+                gasLimit: 21000n,
+                gasPrice,
+                chainId,
+                type: txType
+            }));
+            currentAmount = sendAmount;
+        }
+    }
+    else {
+        // 没有中间跳板，直接 Main -> Buyer
+        // Main 收到了钱，现在转给 Buyer
+        if (currentAmount <= transferGasCost)
+            throw new Error('资金不足以支付主钱包转账 Gas');
+        const sendAmount = currentAmount - transferGasCost;
+        signedTxs.push(await currentFrom.signTransaction({
+            to: buyerAddress,
+            value: sendAmount,
+            nonce: currentNonce,
+            gasLimit: 21000n,
+            gasPrice,
+            chainId,
+            type: txType
+        }));
+        currentAmount = sendAmount;
+    }
+    return {
+        signedTxs,
+        finalAmount: currentAmount,
+        hopInfo: {
+            count: hopCount,
+            addresses: hopAddresses
         }
     };
 }

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

@@ -276,3 +276,49 @@ export type PancakeProxyApprovalBatchResult = {
     bundleHash?: string;
     message: string;
 };
+/** ✅ 资金路由配置 */
+export type FundRoutingConfig = {
+    /** 主钱包私钥（必填）：Seller 的资金会先归集到这里，再分发给 Buyer */
+    mainPrivateKey: string;
+    /** 中间跳板配置（可选）：用于混淆资金链路 */
+    hops?: {
+        /** 跳板数量（如果指定，将自动生成随机钱包） */
+        count?: number;
+        /** 指定跳板钱包私钥（如果指定，优先使用，长度必须等于 count） */
+        privateKeys?: string[];
+    };
+};
+/** ✅ Flap 捆绑换手参数（仅签名版本） */
+export type FlapBundleSwapSignParams = {
+    chain: 'bsc' | 'opbnb';
+    sellerPrivateKey: string;
+    sellAmount?: string;
+    sellPercentage?: number;
+    buyerPrivateKey: string;
+    tokenAddress: string;
+    config: FlapSignConfig & {
+        slippageBps?: number;
+        reserveGasETH?: string;
+        skipQuoteOnError?: boolean;
+        skipApprovalCheck?: boolean;
+    };
+    /** 资金路由配置（可选）：如果有，将执行 卖出->主钱包->跳板->买家->买入 的完整链路 */
+    routing?: FundRoutingConfig;
+};
+/** ✅ Flap 换手结果 */
+export type FlapSwapResult = MerkleSignedResult & {
+    metadata: {
+        sellerAddress: string;
+        buyerAddress: string;
+        sellAmount: string;
+        buyAmount: string;
+        hasApproval: boolean;
+        profitAmount?: string;
+        /** 路由信息 */
+        routing?: {
+            mainAddress: string;
+            hopAddresses: string[];
+            totalHops: number;
+        };
+    };
+};

package/package.json

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