four-flap-meme-sdk 1.1.92 → 1.1.94

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.d.ts

@@ -5,13 +5,20 @@ export type ApproveFourTokenManagerBatchParams = {
     config: {
         apiKey: string;
         customRpcUrl?: string;
+        chainId?: number;
+        bundleBlockOffset?: number;
         gasLimit?: number | bigint;
         gasLimitMultiplier?: number;
+        gasPriceMultiplierPercent?: number;
+        minGasPriceGwei?: number;
         txType?: 0 | 2;
     };
 };
 export type ApproveFourTokenManagerBatchResult = {
-    signedTransactions: string[];
+    success: boolean;
+    approvedCount: number;
+    bundleHash?: string;
+    message: string;
 };
 /**
  * 批量授权代币给 TokenManager（用于 Private Buy/Sell）

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

@@ -21,9 +21,10 @@ export async function approveFourTokenManagerBatch(params) {
         throw new Error('Private key count and amount count must match');
     }
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
+    const chainId = config.chainId ?? 56;
     const merkle = new MerkleClient({
         apiKey: config.apiKey,
-        chainId: 56,
+        chainId: chainId,
         customRpcUrl: config.customRpcUrl
     });
     const provider = merkle.getProvider();
@@ -44,19 +45,26 @@ export async function approveFourTokenManagerBatch(params) {
     console.log(`   - 需要授权: ${needApproval.length}`);
     console.log(`   - 已有授权: ${wallets.length - needApproval.length}`);
     if (needApproval.length === 0) {
-        // 全部已授权，直接返回
-        console.log(`✅ 所有钱包已授权给 TokenManager`);
+        console.log('✅ 所有钱包已授权，无需再次授权。');
         return {
-            signedTransactions: []
+            success: true,
+            approvedCount: 0,
+            message: '所有钱包已授权'
         };
     }
     // 构建授权交易
     const needApprovalTokens = needApproval.map(w => new ethers.Contract(tokenAddress, ERC20_ABI, w));
     const unsignedApprovals = await Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i])));
-    // ✅ 使用前端传入的 gasLimit，否则使用默认值
-    const gasMultiplier = config.gasLimitMultiplier ?? 1.0;
-    const finalGasLimit = config.gasLimit ?? BigInt(Math.ceil(50000 * gasMultiplier));
-    // ✅ 直接签名交易（不提交到Merkle）
+    // 使用前端传入的 gasLimit，否则使用默认值
+    const getGasLimit = (cfg) => {
+        if (cfg.gasLimit)
+            return BigInt(cfg.gasLimit);
+        if (cfg.gasLimitMultiplier)
+            return BigInt(Math.ceil(21000 * cfg.gasLimitMultiplier));
+        return 21000n; // 默认授权 gas limit
+    };
+    const finalGasLimit = getGasLimit(config);
+    // 签名授权交易
     const nonceManager = new NonceManager(provider);
     const nonces = await Promise.all(needApproval.map(w => nonceManager.getNextNonce(w)));
     const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
@@ -65,13 +73,40 @@ export async function approveFourTokenManagerBatch(params) {
         nonce: nonces[i],
         gasLimit: finalGasLimit,
         gasPrice,
-        chainId: 56,
+        chainId,
         type: getTxType(config)
     })));
     nonceManager.clearTemp();
     console.log(`✅ 已生成 ${signedTxs.length} 个授权交易签名`);
-    // ✅ 简化返回：只返回签名交易
-    return {
-        signedTransactions: signedTxs
-    };
+    // ✅ 内部提交到 Merkle
+    const currentBlock = await provider.getBlockNumber();
+    const targetBlock = currentBlock + (config.bundleBlockOffset ?? 2);
+    console.log(`📤 正在提交授权交易到 Merkle...`);
+    const bundleResult = await merkle.sendBundle({
+        transactions: signedTxs,
+        targetBlock: targetBlock
+    });
+    console.log(`✅ 授权交易已提交，bundleHash: ${bundleResult.bundleHash}`);
+    // ✅ 等待授权确认
+    console.log(`⏳ 等待授权交易确认（约5-10秒）...`);
+    const confirmResults = await merkle.waitForBundleConfirmation(bundleResult.txHashes, 1, 60000);
+    const successCount = confirmResults.filter(r => r.success).length;
+    if (successCount > 0) {
+        console.log(`✅ 授权已确认，共 ${successCount} 笔交易成功`);
+        return {
+            success: true,
+            approvedCount: successCount,
+            bundleHash: bundleResult.bundleHash,
+            message: `授权成功，共 ${successCount} 个钱包`
+        };
+    }
+    else {
+        console.log(`⚠️ 授权交易未确认`);
+        return {
+            success: false,
+            approvedCount: 0,
+            bundleHash: bundleResult.bundleHash,
+            message: '授权交易未确认'
+        };
+    }
 }

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

@@ -4,6 +4,7 @@ import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.j
 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';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function createToken(bytes args, bytes signature) payable',
@@ -335,7 +336,6 @@ export async function batchSellWithBundleMerkle(params) {
         'function allowance(address owner, address spender) view returns (uint256)'
     ];
     console.log('🔍 使用 Multicall3 批量检查授权状态...');
-    const { batchCheckAllowances } = await import('../../utils/erc20.js');
     const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), tmAddr);
     // 找出需要授权的钱包索引
     // 使用 MaxUint256 的一半作为阈值，确保能处理超大供应量代币
@@ -352,7 +352,7 @@ export async function batchSellWithBundleMerkle(params) {
     // ✅ Step 2: 批量授权（如果需要）
     // ⚠️ 注意：授权需要单独提交，SDK只返回签名交易
     if (needApprovalIndexes.length > 0) {
-        console.log('⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权');
+        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
         console.log('   请先使用这些钱包的私钥调用授权方法，授权完成后再调用卖出方法');
         throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包尚未授权。请先完成授权后再卖出。`);
     }

package/dist/contracts/tm-bundle-merkle/pancake-proxy.js

@@ -3,6 +3,7 @@ import { MerkleClient } from '../../clients/merkle.js';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getBundleOptions, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit } from './config.js';
+import { batchCheckAllowances } from '../../utils/erc20.js';
 // 常量
 const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
 const FLAT_FEE = ethers.parseEther('0.0001'); // 合约固定手续费
@@ -215,18 +216,24 @@ export async function approveFourPancakeProxyBatch(params) {
     // 只授权不足的
     const needApproval = wallets.filter((_, i) => allowances[i] < amountsBigInt[i]);
     const needApprovalAmounts = amountsBigInt.filter((amount, i) => allowances[i] < amount);
+    console.log(`🔍 PancakeProxy 授权检查:`);
+    console.log(`   - 总钱包数: ${wallets.length}`);
+    console.log(`   - 需要授权: ${needApproval.length}`);
+    console.log(`   - 已有授权: ${wallets.length - needApproval.length}`);
     if (needApproval.length === 0) {
-        // 全部已授权，直接返回
+        console.log('✅ 所有钱包已授权，无需再次授权。');
         return {
-            signedTransactions: []
+            success: true,
+            approvedCount: 0,
+            message: '所有钱包已授权'
         };
     }
     // 构建授权交易
     const needApprovalTokens = needApproval.map(w => new Contract(tokenAddress, ERC20_ABI, w));
     const unsignedApprovals = await Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(pancakeProxyAddress, needApprovalAmounts[i])));
-    // ✅ 使用前端传入的 gasLimit，否则使用默认值
+    // 使用前端传入的 gasLimit，否则使用默认值
     const finalGasLimit = getGasLimit(config);
-    // ✅ 直接签名交易（不提交到Merkle）
+    // 签名授权交易
     const nonceManager = new NonceManager(provider);
     const nonces = await Promise.all(needApproval.map(w => nonceManager.getNextNonce(w)));
     const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
@@ -239,10 +246,38 @@ export async function approveFourPancakeProxyBatch(params) {
         type: getTxType(config)
     })));
     nonceManager.clearTemp();
-    // ✅ 简化返回：只返回签名交易
-    return {
-        signedTransactions: signedTxs
-    };
+    console.log(`✅ 已生成 ${signedTxs.length} 个授权交易签名`);
+    // ✅ 内部提交到 Merkle
+    const currentBlock = await provider.getBlockNumber();
+    const targetBlock = currentBlock + blockOffset;
+    console.log(`📤 正在提交授权交易到 Merkle...`);
+    const bundleResult = await merkle.sendBundle({
+        transactions: signedTxs,
+        targetBlock: targetBlock
+    });
+    console.log(`✅ 授权交易已提交，bundleHash: ${bundleResult.bundleHash}`);
+    // ✅ 等待授权确认
+    console.log(`⏳ 等待授权交易确认（约5-10秒）...`);
+    const confirmResults = await merkle.waitForBundleConfirmation(bundleResult.txHashes, 1, 60000);
+    const successCount = confirmResults.filter(r => r.success).length;
+    if (successCount > 0) {
+        console.log(`✅ 授权已确认，共 ${successCount} 笔交易成功`);
+        return {
+            success: true,
+            approvedCount: successCount,
+            bundleHash: bundleResult.bundleHash,
+            message: `授权成功，共 ${successCount} 个钱包`
+        };
+    }
+    else {
+        console.log(`⚠️ 授权交易未确认`);
+        return {
+            success: false,
+            approvedCount: 0,
+            bundleHash: bundleResult.bundleHash,
+            message: '授权交易未确认'
+        };
+    }
 }
 /**
  * 使用 PancakeSwapProxy 批量购买代币（Merkle 版本）
@@ -364,7 +399,6 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
     // ✅ Step 1: 使用 Multicall3 批量检查授权状态
     console.log('🔍 使用 Multicall3 批量检查授权状态...');
-    const { batchCheckAllowances } = await import('../../utils/erc20.js');
     const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress);
     // 找出需要授权的钱包索引
     const needApprovalIndexes = [];
@@ -380,7 +414,7 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     // ✅ Step 2: 如果需要授权，抛出错误提示
     // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (needApprovalIndexes.length > 0) {
-        console.log('⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权');
+        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
         console.log('   请先使用这些钱包完成授权后再调用卖出方法');
         throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包尚未授权。请先完成授权后再卖出。`);
     }

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

@@ -3,6 +3,7 @@ import { MerkleClient } from '../../clients/merkle.js';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit } from './config.js';
+import { batchCheckAllowances } from '../../utils/erc20.js';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function buyTokenAMAP(uint256 origin, address token, address to, uint256 funds, uint256 minAmount) payable',
@@ -244,7 +245,6 @@ export async function fourBatchPrivateSellMerkle(params) {
     const amountsWei = amounts.map((a) => ethers.parseUnits(a, 18));
     // ✅ Step 1: 使用 Multicall3 批量检查授权状态
     console.log('🔍 使用 Multicall3 批量检查授权状态...');
-    const { batchCheckAllowances } = await import('../../utils/erc20.js');
     const allowances = await batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr);
     // 找出需要授权的钱包索引
     // 使用 MaxUint256 的一半作为阈值，确保能处理超大供应量代币
@@ -261,7 +261,7 @@ export async function fourBatchPrivateSellMerkle(params) {
     // ✅ Step 2: 如果需要授权，抛出错误提示
     // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (needApprovalIndexes.length > 0) {
-        console.log('⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权');
+        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
         console.log('   请先使用这些钱包完成授权后再调用卖出方法');
         throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包尚未授权。请先完成授权后再卖出。`);
     }

package/dist/contracts/tm-bundle-merkle/types.d.ts

@@ -215,5 +215,10 @@ export type FourPancakeProxyApprovalBatchParams = {
     amounts: (string | 'max')[];
     config: FourBundleMerkleConfig;
 };
-/** ✅ PancakeProxy 批量授权结果（简化版） */
-export type FourPancakeProxyApprovalBatchResult = MerkleSignedResult;
+/** ✅ PancakeProxy 批量授权结果 */
+export type FourPancakeProxyApprovalBatchResult = {
+    success: boolean;
+    approvedCount: number;
+    bundleHash?: string;
+    message: string;
+};

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

@@ -3,6 +3,7 @@ import { MerkleClient } from '../../clients/merkle.js';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { CHAIN_ID_MAP, getTxType, getBundleOptions, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit } from './config.js';
+import { batchCheckAllowances } from '../../utils/erc20.js';
 // 常量
 const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
 const FLAT_FEE = ethers.parseEther('0.0001'); // 合约固定手续费
@@ -216,18 +217,24 @@ export async function approvePancakeProxyBatch(params) {
     // 只授权不足的
     const needApproval = wallets.filter((_, i) => allowances[i] < amountsBigInt[i]);
     const needApprovalAmounts = amountsBigInt.filter((amount, i) => allowances[i] < amount);
+    console.log(`🔍 PancakeProxy 授权检查:`);
+    console.log(`   - 总钱包数: ${wallets.length}`);
+    console.log(`   - 需要授权: ${needApproval.length}`);
+    console.log(`   - 已有授权: ${wallets.length - needApproval.length}`);
     if (needApproval.length === 0) {
-        // 全部已授权，直接返回
+        console.log('✅ 所有钱包已授权，无需再次授权。');
         return {
-            signedTransactions: []
+            success: true,
+            approvedCount: 0,
+            message: '所有钱包已授权'
         };
     }
     // 构建授权交易
     const needApprovalTokens = needApproval.map(w => new Contract(tokenAddress, ERC20_ABI, w));
     const unsignedApprovals = await Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(pancakeProxyAddress, needApprovalAmounts[i])));
-    // ✅ 使用前端传入的 gasLimit，否则使用默认值
+    // 使用前端传入的 gasLimit，否则使用默认值
     const finalGasLimit = getGasLimit(config);
-    // ✅ 直接签名交易（不提交到Merkle）
+    // 签名授权交易
     const nonceManager = new NonceManager(provider);
     const nonces = await Promise.all(needApproval.map(w => nonceManager.getNextNonce(w)));
     const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
@@ -240,10 +247,38 @@ export async function approvePancakeProxyBatch(params) {
         type: getTxType(config)
     })));
     nonceManager.clearTemp();
-    // ✅ 简化返回：只返回签名交易
-    return {
-        signedTransactions: signedTxs
-    };
+    console.log(`✅ 已生成 ${signedTxs.length} 个授权交易签名`);
+    // ✅ 内部提交到 Merkle
+    const currentBlock = await provider.getBlockNumber();
+    const targetBlock = currentBlock + blockOffset;
+    console.log(`📤 正在提交授权交易到 Merkle...`);
+    const bundleResult = await merkle.sendBundle({
+        transactions: signedTxs,
+        targetBlock: targetBlock
+    });
+    console.log(`✅ 授权交易已提交，bundleHash: ${bundleResult.bundleHash}`);
+    // ✅ 等待授权确认
+    console.log(`⏳ 等待授权交易确认（约5-10秒）...`);
+    const confirmResults = await merkle.waitForBundleConfirmation(bundleResult.txHashes, 1, 60000);
+    const successCount = confirmResults.filter(r => r.success).length;
+    if (successCount > 0) {
+        console.log(`✅ 授权已确认，共 ${successCount} 笔交易成功`);
+        return {
+            success: true,
+            approvedCount: successCount,
+            bundleHash: bundleResult.bundleHash,
+            message: `授权成功，共 ${successCount} 个钱包`
+        };
+    }
+    else {
+        console.log(`⚠️ 授权交易未确认`);
+        return {
+            success: false,
+            approvedCount: 0,
+            bundleHash: bundleResult.bundleHash,
+            message: '授权交易未确认'
+        };
+    }
 }
 /**
  * 使用 PancakeSwapProxy 批量购买代币（Merkle 版本）
@@ -367,7 +402,6 @@ export async function pancakeProxyBatchSellMerkle(params) {
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
     // ✅ Step 1: 使用 Multicall3 批量检查授权状态
     console.log('🔍 使用 Multicall3 批量检查授权状态...');
-    const { batchCheckAllowances } = await import('../../utils/erc20.js');
     const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress);
     // 找出需要授权的钱包索引
     const needApprovalIndexes = [];
@@ -383,7 +417,7 @@ export async function pancakeProxyBatchSellMerkle(params) {
     // ✅ Step 2: 如果需要授权，抛出错误提示
     // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (needApprovalIndexes.length > 0) {
-        console.log('⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权');
+        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
         console.log('   请先使用这些钱包完成授权后再调用卖出方法');
         throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包尚未授权。请先完成授权后再卖出。`);
     }

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

@@ -187,5 +187,10 @@ export type PancakeProxyApprovalBatchParams = {
     amounts: (string | 'max')[];
     config: FlapBundleMerkleConfig;
 };
-/** ✅ PancakeProxy 批量授权结果（简化版） */
-export type PancakeProxyApprovalBatchResult = MerkleSignedResult;
+/** ✅ PancakeProxy 批量授权结果 */
+export type PancakeProxyApprovalBatchResult = {
+    success: boolean;
+    approvedCount: number;
+    bundleHash?: string;
+    message: string;
+};

package/package.json

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