four-flap-meme-sdk 1.4.77 → 1.4.79

package/dist/contracts/tm-bundle-merkle/swap-buy-first.d.ts

@@ -18,10 +18,12 @@ export interface FourBuyFirstConfig extends CommonBundleConfig {
     waitTimeoutMs?: number;
 }
 export interface FourBundleBuyFirstSignParams {
-    buyerPrivateKey: string;
+    buyerPrivateKey?: string;
+    buyerPrivateKeys?: string[];
     buyerFunds?: string;
     buyerFundsPercentage?: number;
-    sellerPrivateKey: string;
+    sellerPrivateKey?: string;
+    sellerPrivateKeys?: string[];
     tokenAddress: string;
     config: FourBuyFirstSignConfig;
     buyCount?: number;

package/dist/contracts/tm-bundle-merkle/swap-buy-first.js

@@ -26,8 +26,8 @@ const BRIBE_TX_COUNT = 1;
 const PROFIT_TX_COUNT = PROFIT_HOP_COUNT + 2; // 2 + 2 = 4
 /** 最大买卖交易数 */
 const MAX_SWAP_TX_COUNT = MAX_BUNDLE_SIGNATURES - BRIBE_TX_COUNT - PROFIT_TX_COUNT; // 50 - 1 - 4 = 45
-/** 每笔交易利润比例（基点）：3 bps = 0.03% = 万分之三 */
-const PROFIT_RATE_PER_TX_BPS = 3;
+/** 每笔交易利润比例（基点）：6 bps = 0.06% = 万分之六 */
+const PROFIT_RATE_PER_TX_BPS = 6;
 /**
  * 验证买卖笔数
  */
@@ -83,10 +83,26 @@ function splitAmount(totalAmount, count) {
     return amounts;
 }
 export async function fourBundleBuyFirstMerkle(params) {
-    const { buyerPrivateKey, buyerFunds, buyerFundsPercentage, sellerPrivateKey, tokenAddress, config, buyCount: _buyCount, sellCount: _sellCount } = params;
-    // ✅ 解析并验证买卖笔数
+    const { buyerPrivateKey, buyerPrivateKeys, buyerFunds, buyerFundsPercentage, sellerPrivateKey, sellerPrivateKeys, tokenAddress, config, buyCount: _buyCount, sellCount: _sellCount } = params;
+    // ✅ 判断是否为多钱包模式
+    const isMultiWalletMode = !!(buyerPrivateKeys && buyerPrivateKeys.length > 0) ||
+        !!(sellerPrivateKeys && sellerPrivateKeys.length > 0);
     const buyCount = _buyCount ?? 1;
     const sellCount = _sellCount ?? 1;
+    // ✅ 多钱包模式：使用单独的处理逻辑
+    if (isMultiWalletMode) {
+        return await fourBundleBuyFirstMultiWallet({
+            buyerPrivateKeys: buyerPrivateKeys || (buyerPrivateKey ? [buyerPrivateKey] : []),
+            sellerPrivateKeys: sellerPrivateKeys || (sellerPrivateKey ? [sellerPrivateKey] : []),
+            tokenAddress,
+            buyerFunds,
+            config
+        });
+    }
+    // ✅ 单钱包模式（向后兼容）
+    if (!buyerPrivateKey || !sellerPrivateKey) {
+        throw new Error('单钱包模式需要提供 buyerPrivateKey 和 sellerPrivateKey');
+    }
     validateSwapCounts(buyCount, sellCount);
     // ✅ 计算利润比例：每笔万分之3
     const totalTxCount = buyCount + sellCount;
@@ -139,14 +155,8 @@ export async function fourBundleBuyFirstMerkle(params) {
     if (!estimatedTokenAmount || estimatedTokenAmount <= 0n) {
         throw new Error('报价失败：无法估算可买入的代币数量');
     }
-    // ✅ 多笔交易时添加滑点保护，避免因价格变动导致代币不足
-    // 原因：多笔买入会累积滑点，实际获得的代币少于一次性报价
-    // 滑点比例：buyCount * 1%（每多一笔买入增加 1% 保护）
-    let sellAmountWei = estimatedTokenAmount;
-    if (buyCount > 1 || sellCount > 1) {
-        const slippageBps = BigInt(buyCount * 100); // buyCount=3 → 3%
-        sellAmountWei = estimatedTokenAmount * (10000n - slippageBps) / 10000n;
-    }
+    // ✅ 卖出数量直接使用估算的代币数量（无滑点保护）
+    const sellAmountWei = estimatedTokenAmount;
     // 卖方余额检查
     if (!sameAddress && sellerTokenBal < sellAmountWei) {
         throw new Error(`卖方代币余额不足: 需要 ${ethers.formatUnits(sellAmountWei, decimals)}，实际 ${ethers.formatUnits(sellerTokenBal, decimals)}`);
@@ -298,3 +308,176 @@ async function planMultiNonces({ buyer, seller, buyCount, sellCount, extractProf
     const profitNonce = extractProfit ? sellerNoncesAll[idx] : undefined;
     return { buyerNonces, sellerNonces, bribeNonce, profitNonce };
 }
+/**
+ * ✅ Four 多钱包捆绑换手
+ * - 多个买方钱包执行买入（每个钱包1笔）
+ * - 多个卖方钱包执行卖出（每个钱包1笔）
+ * - 买入总价值 = 卖出总价值
+ */
+async function fourBundleBuyFirstMultiWallet(params) {
+    const { buyerPrivateKeys, sellerPrivateKeys, tokenAddress, buyerFunds, config } = params;
+    const buyCount = buyerPrivateKeys.length;
+    const sellCount = sellerPrivateKeys.length;
+    if (buyCount === 0)
+        throw new Error('买方钱包数量不能为0');
+    if (sellCount === 0)
+        throw new Error('卖方钱包数量不能为0');
+    // 验证总交易数不超过限制
+    validateSwapCounts(buyCount, sellCount);
+    // ✅ 计算利润比例：每笔万分之6
+    const totalTxCount = buyCount + sellCount;
+    const profitRateBps = PROFIT_RATE_PER_TX_BPS * totalTxCount;
+    const chainIdNum = config.chainId ?? 56;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+        chainId: chainIdNum,
+        name: 'BSC'
+    });
+    const nonceManager = new NonceManager(provider);
+    // 创建所有钱包实例
+    const buyers = buyerPrivateKeys.map(pk => new Wallet(pk, provider));
+    const sellers = sellerPrivateKeys.map(pk => new Wallet(pk, provider));
+    // 使用第一个卖方作为主卖方（支付贿赂和利润）
+    const mainSeller = sellers[0];
+    // ✅ 计算总交易金额
+    if (!buyerFunds) {
+        throw new Error('多钱包模式必须提供 buyerFunds（总交易金额）');
+    }
+    const totalFundsWei = ethers.parseEther(String(buyerFunds));
+    if (totalFundsWei <= 0n) {
+        throw new Error('交易金额必须大于0');
+    }
+    // ✅ 获取报价：买入能获得多少代币
+    const helper3 = new Contract(ADDRESSES.BSC.TokenManagerHelper3, HELPER3_ABI, provider);
+    const buyQuote = await helper3.tryBuy(tokenAddress, 0n, totalFundsWei);
+    const estimatedTokenAmount = buyQuote.estimatedAmount ?? buyQuote[2];
+    if (!estimatedTokenAmount || estimatedTokenAmount <= 0n) {
+        throw new Error('报价失败：无法估算可买入的代币数量');
+    }
+    // ✅ 将总金额平均分配给买方
+    const buyAmountsWei = splitAmount(totalFundsWei, buyCount);
+    // ✅ 将代币平均分配给卖方
+    const sellAmountsWei = splitAmount(estimatedTokenAmount, sellCount);
+    const finalGasLimit = getGasLimit(config);
+    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
+    const txType = getTxType(config);
+    // ✅ 估算利润
+    const sellResult = await trySell('BSC', config.rpcUrl, tokenAddress, estimatedTokenAmount);
+    const estimatedSellFunds = sellResult.funds;
+    const profitAmount = (estimatedSellFunds * BigInt(profitRateBps)) / 10000n;
+    // ✅ 获取贿赂金额
+    const bribeAmount = getBribeAmount(config);
+    const needBribeTx = bribeAmount > 0n;
+    // ✅ 获取所有钱包的 nonces
+    const noncesMap = new Map();
+    await Promise.all([...sellers, ...buyers].map(async (wallet) => {
+        const addr = wallet.address.toLowerCase();
+        if (!noncesMap.has(addr)) {
+            const nonce = await nonceManager.getNextNonce(wallet);
+            noncesMap.set(addr, nonce);
+        }
+    }));
+    // ✅ 构建交易列表
+    const allTransactions = [];
+    // 1. 贿赂交易（由主卖方支付）
+    if (needBribeTx) {
+        const mainSellerAddr = mainSeller.address.toLowerCase();
+        const bribeNonce = noncesMap.get(mainSellerAddr);
+        noncesMap.set(mainSellerAddr, bribeNonce + 1);
+        const bribeTx = await mainSeller.signTransaction({
+            to: BLOCKRAZOR_BUILDER_EOA,
+            value: bribeAmount,
+            nonce: bribeNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: chainIdNum,
+            type: txType
+        });
+        allTransactions.push(bribeTx);
+    }
+    // 2. 构建所有买入交易
+    const tm = new Contract(TM_ADDRESS, TM_ABI, provider);
+    const buyTxPromises = buyers.map(async (buyer, i) => {
+        const buyAmount = buyAmountsWei[i];
+        const buyerAddr = buyer.address.toLowerCase();
+        const nonce = noncesMap.get(buyerAddr);
+        noncesMap.set(buyerAddr, nonce + 1);
+        const tmBuyer = tm.connect(buyer);
+        const unsigned = await tmBuyer.buyTokenAMAP.populateTransaction(0n, tokenAddress, buyer.address, buyAmount, 0n, { value: buyAmount });
+        return buyer.signTransaction({
+            ...unsigned,
+            from: buyer.address,
+            nonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            chainId: chainIdNum,
+            type: txType,
+            value: buyAmount
+        });
+    });
+    // 3. 构建所有卖出交易
+    const sellTxPromises = sellers.map(async (seller, i) => {
+        const sellAmount = sellAmountsWei[i];
+        const sellerAddr = seller.address.toLowerCase();
+        const nonce = noncesMap.get(sellerAddr);
+        noncesMap.set(sellerAddr, nonce + 1);
+        const tmSeller = tm.connect(seller);
+        const unsigned = await tmSeller.sellToken.populateTransaction(0n, tokenAddress, sellAmount, 0n);
+        return seller.signTransaction({
+            ...unsigned,
+            from: seller.address,
+            nonce,
+            gasLimit: finalGasLimit,
+            gasPrice,
+            chainId: chainIdNum,
+            type: txType,
+            value: 0n
+        });
+    });
+    // ✅ 并行签名所有买卖交易
+    const [signedBuys, signedSells] = await Promise.all([
+        Promise.all(buyTxPromises),
+        Promise.all(sellTxPromises)
+    ]);
+    // 先买后卖：买入交易在前
+    allTransactions.push(...signedBuys, ...signedSells);
+    // 4. 利润多跳转账（由主卖方支付）
+    let profitHopWallets;
+    if (profitAmount > 0n) {
+        const mainSellerAddr = mainSeller.address.toLowerCase();
+        const profitNonce = noncesMap.get(mainSellerAddr);
+        const profitHopResult = await buildProfitHopTransactions({
+            provider,
+            payerWallet: mainSeller,
+            profitAmount,
+            profitRecipient: getProfitRecipient(),
+            hopCount: PROFIT_HOP_COUNT,
+            gasPrice,
+            chainId: chainIdNum,
+            txType,
+            startNonce: profitNonce
+        });
+        allTransactions.push(...profitHopResult.signedTransactions);
+        profitHopWallets = profitHopResult.hopWallets;
+    }
+    nonceManager.clearTemp();
+    // 获取代币精度用于显示
+    const erc20 = new Contract(tokenAddress, [
+        'function decimals() view returns (uint8)'
+    ], provider);
+    const decimals = await erc20.decimals();
+    return {
+        signedTransactions: allTransactions,
+        profitHopWallets,
+        metadata: {
+            buyerAddress: buyers.map(b => b.address).join(','),
+            sellerAddress: sellers.map(s => s.address).join(','),
+            buyAmount: ethers.formatEther(totalFundsWei),
+            sellAmount: ethers.formatUnits(estimatedTokenAmount, decimals),
+            profitAmount: profitAmount > 0n ? ethers.formatEther(profitAmount) : undefined,
+            buyCount,
+            sellCount,
+            buyAmounts: buyAmountsWei.map(amt => ethers.formatEther(amt)),
+            sellAmounts: sellAmountsWei.map(amt => ethers.formatUnits(amt, decimals))
+        }
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
+/**
+ * 验证公钥格式（Base64）
+ */
+export declare function validatePublicKey(publicKeyBase64: string): boolean;

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

@@ -0,0 +1,146 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 获取全局 crypto 对象（最简单直接的方式）
+ */
+function getCryptoAPI() {
+    // 尝试所有可能的全局对象，优先浏览器环境
+    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
+        (typeof self !== 'undefined' && self.crypto) ||
+        (typeof global !== 'undefined' && global.crypto) ||
+        (typeof globalThis !== 'undefined' && globalThis.crypto);
+    if (!cryptoObj) {
+        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
+            '请确保在 HTTPS 或 localhost 下运行');
+    }
+    return cryptoObj;
+}
+/**
+ * 获取 SubtleCrypto（用于加密操作）
+ */
+function getSubtleCrypto() {
+    const crypto = getCryptoAPI();
+    if (!crypto.subtle) {
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
+        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
+            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
+            '3) 不在无痕/隐私浏览模式下');
+    }
+    return crypto.subtle;
+}
+/**
+ * Base64 转 ArrayBuffer（优先使用浏览器 API）
+ */
+function base64ToArrayBuffer(base64) {
+    // 浏览器环境（优先）
+    if (typeof atob !== 'undefined') {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(base64, 'base64').buffer;
+    }
+    throw new Error('❌ Base64 解码不可用');
+}
+/**
+ * ArrayBuffer 转 Base64（优先使用浏览器 API）
+ */
+function arrayBufferToBase64(buffer) {
+    // 浏览器环境（优先）
+    if (typeof btoa !== 'undefined') {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(buffer).toString('base64');
+    }
+    throw new Error('❌ Base64 编码不可用');
+}
+/**
+ * 生成随机 Hex 字符串
+ */
+function randomHex(length) {
+    const crypto = getCryptoAPI();
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
+    try {
+        // 0. 获取 SubtleCrypto 和 Crypto API
+        const subtle = getSubtleCrypto();
+        const crypto = getCryptoAPI();
+        // 1. 准备数据
+        const payload = {
+            signedTransactions,
+            timestamp: Date.now(),
+            nonce: randomHex(8)
+        };
+        const plaintext = JSON.stringify(payload);
+        // 2. 生成临时 ECDH 密钥对
+        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
+        // 3. 导入服务器公钥
+        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
+        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+        // 4. 派生共享密钥（AES-256）
+        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
+        // 5. AES-GCM 加密
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
+        // 6. 导出临时公钥
+        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
+        // 7. 返回加密包（JSON 格式）
+        return JSON.stringify({
+            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
+            i: arrayBufferToBase64(iv.buffer), // IV
+            d: arrayBufferToBase64(encrypted) // 密文
+        });
+    }
+    catch (error) {
+        throw new Error(`加密失败: ${error?.message || String(error)}`);
+    }
+}
+/**
+ * 验证公钥格式（Base64）
+ */
+export function validatePublicKey(publicKeyBase64) {
+    try {
+        if (!publicKeyBase64)
+            return false;
+        // Base64 字符集验证
+        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
+            return false;
+        // ECDH P-256 公钥固定长度 65 字节（未压缩）
+        // Base64 编码后约 88 字符
+        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -22,8 +22,10 @@ export interface FlapBuyFirstConfig extends CommonBundleConfig {
 }
 export interface FlapBundleBuyFirstSignParams {
     chain: FlapChain;
-    buyerPrivateKey: string;
-    sellerPrivateKey: string;
+    buyerPrivateKey?: string;
+    buyerPrivateKeys?: string[];
+    sellerPrivateKey?: string;
+    sellerPrivateKeys?: string[];
     tokenAddress: string;
     buyerFunds?: string;
     buyerFundsPercentage?: number;