four-flap-meme-sdk 1.2.1 → 1.2.3

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.js

@@ -48,23 +48,7 @@ export async function approveFourTokenManagerBatch(params) {
     const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
     const needApproval = wallets.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
     const needApprovalAmounts = amountsBigInt.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
-    console.log(`🔍 TokenManager 授权检查:`);
-    console.log(`   - 总钱包数: ${wallets.length}`);
-    console.log(`   - 需要授权: ${needApproval.length}`);
-    console.log(`   - 已有授权: ${wallets.length - needApproval.length}`);
-    // ✅ 显示每个钱包的授权状态
-    for (let i = 0; i < wallets.length; i++) {
-        const current = allowances[i];
-        const requested = amountsBigInt[i];
-        if (current < APPROVAL_THRESHOLD) {
-            console.log(`   ⚠️ 钱包 ${i}: 当前授权 ${ethers.formatUnits(current, decimals)} → 需要重新授权为 ${requested === ethers.MaxUint256 ? 'MAX' : ethers.formatUnits(requested, decimals)}`);
-        }
-        else {
-            console.log(`   ✅ 钱包 ${i}: 授权充足 (${current === ethers.MaxUint256 ? 'MAX' : ethers.formatUnits(current, decimals)})`);
-        }
-    }
     if (needApproval.length === 0) {
-        console.log('✅ 所有钱包已授权，无需再次授权。');
         return {
             success: true,
             approvedCount: 0,

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

@@ -5,6 +5,7 @@ import { ADDRESSES } from '../../utils/constants.js';
 import { FourClient, buildLoginMessage } from '../../clients/four.js';
 import { getErrorMessage, getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+import { trySell } from '../tm.js';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function createToken(bytes args, bytes signature) payable',
@@ -322,24 +323,29 @@ export async function batchSellWithBundleMerkle(params) {
     const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const sellers = privateKeys.map((k) => new Wallet(k, provider));
     const amountsWei = sellAmounts.map((a) => ethers.parseUnits(a, 18));
-    // ⚠️ Four.meme 内盘代币通过 TokenManager bonding curve 定价，不在 PancakeSwap 上
+    // ⚠️ Four.meme 内盘代币通过 TokenManager bonding curve 定价
+    // ✅ 优先使用用户提供的 minOutputAmounts，否则自动调用 trySell 获取
     let minOuts;
     let quotedOutputs = [];
     if (minOutputAmounts && minOutputAmounts.length === sellers.length) {
         // 用户提供了 minOutputAmounts，用于滑点保护和利润计算
         minOuts = minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
-        // 反推实际收益（假设 minOut 是 95% 的收益）
         quotedOutputs = minOuts.map(m => m * 100n / 95n);
     }
     else {
-        // 默认 minOutputAmount = 0（不限制最小输出，不提取利润）
-        minOuts = new Array(sellers.length).fill(0n);
-        quotedOutputs = new Array(sellers.length).fill(0n);
-        // ⚠️ 友好提示
-        if (shouldExtractProfit(config)) {
-            console.log('\n⚠️  提示：未传入 minOutputAmounts，将无法提取利润');
-            console.log('   请在 four.meme 网站查看预期收益，然后传入 minOutputAmounts 参数\n');
-        }
+        // ✅ 自动调用 trySell 获取每个钱包的预期收益
+        const rpcUrl = config.customRpcUrl;
+        quotedOutputs = await Promise.all(amountsWei.map(async (amount, i) => {
+            try {
+                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                return result.funds;
+            }
+            catch (error) {
+                return 0n;
+            }
+        }));
+        // minOuts 设为预期收益的 95%（作为滑点保护）
+        minOuts = quotedOutputs.map(q => q * 95n / 100n);
     }
     // ✅ Step 1: 检查代币余额和授权状态
     const ERC20_ABI = [

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

@@ -4,6 +4,7 @@ import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.j
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+import { trySell } from '../tm.js';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function buyTokenAMAP(uint256 origin, address token, address to, uint256 funds, uint256 minAmount) payable',
@@ -229,16 +230,6 @@ export async function fourBatchPrivateSellMerkle(params) {
     if (privateKeys.length !== amounts.length) {
         throw new Error('privateKeys and amounts length mismatch');
     }
-    // ⚠️ 友好提示：利润提取需要 minFundsEach
-    if (!minFundsEach && shouldExtractProfit(config)) {
-        console.log('\n⚠️  重要提示：未传入 minFundsEach 参数，将无法提取利润！');
-        console.log('   Four.meme 内盘代币无法自动报价，需要手动估算预期收益');
-        console.log('   建议步骤：');
-        console.log('   1. 在 four.meme 网站查看卖出预期收益');
-        console.log('   2. 传入 minFundsEach 参数');
-        console.log('   示例: minFundsEach: 0.1 (预计每个钱包收到 0.1 BNB)');
-        console.log('   如果只是测试卖出，可以忽略此提示\n');
-    }
     const merkle = new MerkleClient({
         apiKey: config.apiKey,
         chainId: 56,
@@ -248,12 +239,35 @@ export async function fourBatchPrivateSellMerkle(params) {
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
     const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const gasMultiplier = config.gasLimitMultiplier ?? 1.0;
-    const minOut = minFundsEach ?? 0n;
     const sellGasLimit = BigInt(Math.ceil(800000 * gasMultiplier));
     const signedTxs = [];
     const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map((k) => new Wallet(k, provider));
     const amountsWei = amounts.map((a) => ethers.parseUnits(a, 18));
+    // ✅ 自动获取每个钱包的预期收益（用于利润计算和滑点保护）
+    let quotedOutputs;
+    let minOuts;
+    if (minFundsEach !== undefined) {
+        // 用户提供了 minFundsEach，所有钱包使用相同的 minOut
+        const minOutWei = typeof minFundsEach === 'string' ? ethers.parseEther(minFundsEach) : minFundsEach;
+        minOuts = new Array(wallets.length).fill(minOutWei);
+        quotedOutputs = minOuts.map(m => m * 100n / 95n);
+    }
+    else {
+        // ✅ 自动调用 trySell 获取每个钱包的预期收益
+        const rpcUrl = config.customRpcUrl;
+        quotedOutputs = await Promise.all(amountsWei.map(async (amount, i) => {
+            try {
+                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                return result.funds;
+            }
+            catch (error) {
+                return 0n;
+            }
+        }));
+        // minOuts 设为预期收益的 95%（作为滑点保护）
+        minOuts = quotedOutputs.map(q => q * 95n / 100n);
+    }
     // ✅ Step 0: 检查代币余额
     const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
     const balances = await Promise.all(wallets.map(w => tokenContract.balanceOf(w.address)));
@@ -288,7 +302,7 @@ export async function fourBatchPrivateSellMerkle(params) {
     }
     // ✅ Step 3: 构建卖出交易
     const tm2Contracts = wallets.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
-    const sellUnsigned = await Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOut)));
+    const sellUnsigned = await Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOuts[i])));
     const sellGasLimits = new Array(wallets.length).fill(sellGasLimit);
     const sellNonces = await Promise.all(wallets.map((w) => nonceManager.getNextNonce(w)));
     const signedSells = await Promise.all(sellUnsigned.map((unsigned, i) => wallets[i].signTransaction({
@@ -301,22 +315,26 @@ export async function fourBatchPrivateSellMerkle(params) {
         type: getTxType(config)
     })));
     signedTxs.push(...signedSells);
-    // ✅ 提取利润
+    // ✅ 提取利润（基于每个钱包的预期收益）
     const extractProfit = shouldExtractProfit(config);
-    if (extractProfit && minOut > 0n) {
-        const { profit } = calculateProfit(minOut, config);
-        if (profit > 0n) {
-            const profitNonces = await Promise.all(wallets.map(w => nonceManager.getNextNonce(w)));
-            const profitTxs = await Promise.all(wallets.map((wallet, i) => wallet.signTransaction({
-                to: config.profitRecipient,
-                value: profit,
-                nonce: profitNonces[i],
-                gasPrice,
-                gasLimit: 21000n,
-                chainId: 56,
-                type: getTxType(config)
-            })));
-            signedTxs.push(...profitTxs);
+    if (extractProfit) {
+        for (let i = 0; i < wallets.length; i++) {
+            if (quotedOutputs[i] > 0n) {
+                const { profit } = calculateProfit(quotedOutputs[i], config);
+                if (profit > 0n) {
+                    const profitNonce = await nonceManager.getNextNonce(wallets[i]);
+                    const profitTx = await wallets[i].signTransaction({
+                        to: config.profitRecipient,
+                        value: profit,
+                        nonce: profitNonce,
+                        gasPrice,
+                        gasLimit: 21000n,
+                        chainId: 56,
+                        type: getTxType(config)
+                    });
+                    signedTxs.push(profitTx);
+                }
+            }
         }
     }
     nonceManager.clearTemp();

package/dist/flap/portal-bundle-merkle/pancake-proxy.js

@@ -15,6 +15,16 @@ const PANCAKE_PROXY_ABI = [
     'function swapV3Single(address tokenIn, address tokenOut, uint24 fee, uint256 amountIn, uint256 amountOutMin, address to) external payable returns (uint256 amountOut)',
     'function swapV3MultiHop(address[] calldata lpAddresses, address exactTokenIn, uint256 amountIn, uint256 amountOutMin, address to) external payable returns (uint256 amountOut)'
 ];
+// PancakeSwap V2 Router ABI（用于报价）
+const PANCAKE_V2_ROUTER_ABI = [
+    'function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)'
+];
+// PancakeSwap V3 QuoterV2 ABI（用于报价）
+const PANCAKE_V3_QUOTER_ABI = [
+    'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96)) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)'
+];
+const PANCAKE_V2_ROUTER_ADDRESS = '0x10ED43C718714eb63d5aA57B78B54704E256024E';
+const PANCAKE_V3_QUOTER_ADDRESS = '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997';
 // ERC20 ABI
 const ERC20_ABI = [
     'function approve(address spender, uint256 amount) external returns (bool)',
@@ -400,8 +410,6 @@ export async function pancakeProxyBatchSellMerkle(params) {
     // 查询 tokenIn decimals
     const tokenDecimals = await getTokenDecimals(tokenAddress, provider);
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
-    // ✅ Step 1: 使用 Multicall3 批量检查授权状态
-    console.log('🔍 使用 Multicall3 批量检查授权状态...');
     const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress);
     // 找出需要授权的钱包索引
     const needApprovalIndexes = [];
@@ -411,9 +419,6 @@ export async function pancakeProxyBatchSellMerkle(params) {
             needApprovalIndexes.push(i);
         }
     }
-    console.log(`   - 总钱包数: ${sellers.length}`);
-    console.log(`   - 需要授权: ${needApprovalIndexes.length}`);
-    console.log(`   - 已有授权: ${sellers.length - needApprovalIndexes.length}\n`);
     // ✅ Step 2: 如果需要授权，抛出错误提示
     // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (needApprovalIndexes.length > 0) {
@@ -421,65 +426,53 @@ export async function pancakeProxyBatchSellMerkle(params) {
         console.log('   请先使用这些钱包完成授权后再调用卖出方法');
         throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包尚未授权。请先完成授权后再卖出。`);
     }
-    // ✅ Step 3: 批量卖出
-    console.log('💰 提交卖出交易...');
-    // 🔍 调试信息 - 详细参数
-    console.log('📊 卖出详情:');
-    console.log(`   [基本信息]`);
-    console.log(`   - 链: ${chain}`);
-    console.log(`   - 代币地址: ${tokenAddress}`);
-    console.log(`   - PancakeProxy: ${pancakeProxyAddress}`);
-    console.log(`   - 卖家数量: ${sellers.length}`);
-    console.log(`   - 路由类型: ${routeType}`);
-    console.log(`\n   [卖家信息]`);
-    sellers.forEach((seller, i) => {
-        console.log(`   - 钱包 ${i + 1}: ${seller.address}`);
-    });
-    console.log(`\n   [卖出金额]`);
-    sellAmounts.forEach((amount, i) => {
-        console.log(`   - 钱包 ${i + 1}: ${amount} TOKEN (${amountsWei[i].toString()} Wei)`);
-    });
-    // 计算 minOutputAmounts（通常是 BNB/WBNB，18 位）
+    // ✅ 自动获取报价或使用用户提供的 minOutputAmounts
     let minOuts;
+    let quotedOutputs;
     if (params.minOutputAmounts && params.minOutputAmounts.length === sellers.length) {
+        // 用户提供了 minOutputAmounts
         minOuts = params.minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
-        console.log(`\n   [最小输出]`);
-        params.minOutputAmounts.forEach((min, i) => {
-            console.log(`   - 钱包 ${i + 1}: ${min} BNB`);
-        });
+        quotedOutputs = minOuts.map(m => m * 100n / 95n); // 反推预期收益
     }
     else {
-        minOuts = new Array(sellers.length).fill(0n);
-        console.log(`\n   [最小输出] 未设置（默认 0，无滑点保护）`);
-    }
-    console.log(`\n   [路由信息]`);
-    if (routeType === 'v2' && params.v2Path) {
-        console.log(`   - V2 路径: ${params.v2Path.join(' → ')}`);
-    }
-    else if (routeType === 'v3-single') {
-        console.log(`   - V3 单跳: ${tokenAddress} → ${params.v3TokenOut}`);
-        console.log(`   - 费率: ${params.v3Fee}`);
-    }
-    else if (routeType === 'v3-multi') {
-        console.log(`   - V3 多跳 LP 数量: ${params.v3LpAddresses?.length}`);
-        console.log(`   - 起始代币: ${params.v3ExactTokenIn}`);
+        // ✅ 自动调用 PancakeSwap 获取报价
+        quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
+            try {
+                if (routeType === 'v2') {
+                    const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+                    const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
+                    return amounts[amounts.length - 1];
+                }
+                else if (routeType === 'v3-single') {
+                    const quoter = new Contract(PANCAKE_V3_QUOTER_ADDRESS, PANCAKE_V3_QUOTER_ABI, provider);
+                    const result = await quoter.quoteExactInputSingle.staticCall({
+                        tokenIn: tokenAddress,
+                        tokenOut: params.v3TokenOut,
+                        amountIn: amount,
+                        fee: params.v3Fee,
+                        sqrtPriceLimitX96: 0
+                    });
+                    return result[0];
+                }
+                else {
+                    // v3-multi 使用 v2 备选
+                    if (params.v2Path && params.v2Path.length >= 2) {
+                        const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+                        const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
+                        return amounts[amounts.length - 1];
+                    }
+                    return 0n;
+                }
+            }
+            catch (error) {
+                return 0n;
+            }
+        }));
+        // minOuts 设为预期收益的 95%（滑点保护）
+        minOuts = quotedOutputs.map(q => q * 95n / 100n);
     }
     // 卖出不需要发送 BNB，只需要 flatFee
     const needBNB = false;
-    console.log(`\n   [交易费用]`);
-    console.log(`   - 需要发送 BNB: ${needBNB ? '是' : '否'}`);
-    console.log(`   - 每笔手续费: 0.0001 BNB`);
-    console.log(`   - 总手续费: ${ethers.formatEther(BigInt(sellers.length) * ethers.parseEther('0.0001'))} BNB`);
-    console.log(`\n   [Gas 配置]`);
-    console.log(`   - Gas Price: ${ethers.formatUnits(gasPrice, 'gwei')} Gwei`);
-    console.log(`   - Gas Limit: ${config.gasLimit || 'Auto (800000 * multiplier)'}`);
-    if (config.gasLimitMultiplier) {
-        console.log(`   - Gas Multiplier: ${config.gasLimitMultiplier}x`);
-    }
-    console.log(`\n   [Bundle 配置]`);
-    console.log(`   - Block Offset: ${blockOffset}`);
-    console.log(`   - Wait Confirmation: ${config.waitForConfirmation ?? false}`);
-    console.log(`   - Timeout: ${(config.waitTimeoutMs ?? 120000) / 1000}s\n`);
     // 构建交易
     const proxies = sellers.map(w => new Contract(pancakeProxyAddress, PANCAKE_PROXY_ABI, w));
     let unsignedSells;
@@ -505,20 +498,15 @@ export async function pancakeProxyBatchSellMerkle(params) {
         throw new Error(`Unsupported routeType: ${routeType}`);
     }
     // ✅ Step 4: 验证钱包余额（确保有足够 BNB 支付手续费）
-    console.log('🔍 验证钱包余额...');
     const balances = await Promise.all(sellers.map(w => provider.getBalance(w.address)));
     const minRequiredBNB = ethers.parseEther('0.001'); // 至少需要 0.001 BNB（包括 gas 和手续费）
     const insufficientBalances = balances.filter(b => b < minRequiredBNB);
     if (insufficientBalances.length > 0) {
-        console.warn(`⚠️ 警告: ${insufficientBalances.length} 个钱包 BNB 余额不足 0.001 BNB`);
-        balances.forEach((b, i) => {
-            console.log(`   钱包 ${i + 1}: ${ethers.formatEther(b)} BNB`);
-        });
+        throw new Error(`${insufficientBalances.length} 个钱包 BNB 余额不足 0.001 BNB`);
     }
     // ✅ 使用前端传入的 gasLimit，否则使用默认值
     const finalGasLimit = getGasLimit(config);
     // ✅ 直接签名和提交（内联处理以支持利润转账）
-    console.log('🚀 签名卖出交易...\n');
     const nonceManager = new NonceManager(provider);
     const nonces = await Promise.all(sellers.map(w => nonceManager.getNextNonce(w)));
     const signedTxs = await Promise.all(unsignedSells.map((unsigned, i) => sellers[i].signTransaction({
@@ -531,13 +519,12 @@ export async function pancakeProxyBatchSellMerkle(params) {
         type: getTxType(config),
         value: unsigned.value // ✅ 显式保留 value（手续费）
     })));
-    // ✅ 基于 minFunds 为每个钱包添加利润转账
+    // ✅ 基于预期收益为每个钱包添加利润转账
     const extractProfit = shouldExtractProfit(config);
-    if (extractProfit && minOuts.length > 0) {
-        // 为每个钱包添加利润转账（如果 minOut > 0）
+    if (extractProfit && quotedOutputs.length > 0) {
         for (let i = 0; i < sellers.length; i++) {
-            if (minOuts[i] > 0n) { // ⚠️ 保留这个判断：只对设置了 minOut 的钱包提取利润
-                const { profit } = calculateProfit(minOuts[i], config);
+            if (quotedOutputs[i] > 0n) {
+                const { profit } = calculateProfit(quotedOutputs[i], config);
                 if (profit > 0n) {
                     const profitNonce = await nonceManager.getNextNonce(sellers[i]);
                     const profitTx = await sellers[i].signTransaction({

package/package.json

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