four-flap-meme-sdk 1.4.35 → 1.4.37

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

@@ -12,6 +12,24 @@ export declare function normalizeAmounts(recipients: string[], amount?: AmountLi
  * ✅ 优化：原生代币也使用 Multicall3 批量获取，减少 RPC 调用
  */
 export declare function batchGetBalances(provider: JsonRpcProvider, addresses: string[], tokenAddress?: string): Promise<bigint[]>;
+/**
+ * 通过模拟交易获取 ERC20 转账的最小 Gas Limit
+ * ✅ 使用 eth_estimateGas 预估实际需要的 gas，然后加一个小的缓冲量
+ *
+ * @param provider - Provider 实例
+ * @param tokenAddress - ERC20 代币地址
+ * @param from - 发送方地址
+ * @param to - 接收方地址
+ * @param amount - 转账金额（wei）
+ * @param bufferPercent - 缓冲百分比（默认 5%）
+ * @returns 预估的 gas limit
+ */
+export declare function estimateErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, to: string, amount: bigint, bufferPercent?: number): Promise<bigint>;
+/**
+ * 批量预估多个 ERC20 转账的 Gas Limit
+ * ✅ 选取最大值作为统一的 gas limit（确保所有转账都能成功）
+ */
+export declare function estimateMaxErc20TransferGas(provider: JsonRpcProvider, tokenAddress: string, from: string, recipients: string[], amounts: bigint[], bufferPercent?: number): Promise<bigint>;
 /**
  * 计算 Gas Limit
  * - 原生代币转账：21000 gas（固定）

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

@@ -122,6 +122,70 @@ export async function batchGetBalances(provider, addresses, tokenAddress) {
         }
     }
 }
+/**
+ * 通过模拟交易获取 ERC20 转账的最小 Gas Limit
+ * ✅ 使用 eth_estimateGas 预估实际需要的 gas，然后加一个小的缓冲量
+ *
+ * @param provider - Provider 实例
+ * @param tokenAddress - ERC20 代币地址
+ * @param from - 发送方地址
+ * @param to - 接收方地址
+ * @param amount - 转账金额（wei）
+ * @param bufferPercent - 缓冲百分比（默认 5%）
+ * @returns 预估的 gas limit
+ */
+export async function estimateErc20TransferGas(provider, tokenAddress, from, to, amount, bufferPercent = 5) {
+    try {
+        const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+        const data = iface.encodeFunctionData('transfer', [to, amount]);
+        const estimatedGas = await provider.estimateGas({
+            from,
+            to: tokenAddress,
+            data,
+            value: 0n
+        });
+        // 添加缓冲量（默认 5%）
+        const buffer = (estimatedGas * BigInt(bufferPercent)) / 100n;
+        const finalGas = estimatedGas + buffer;
+        console.log(`[estimateErc20TransferGas] 预估 gas: ${estimatedGas}, 最终 gas limit: ${finalGas} (+${bufferPercent}%)`);
+        return finalGas;
+    }
+    catch (error) {
+        console.warn(`[estimateErc20TransferGas] 预估失败，使用默认值:`, error);
+        // 回退到默认值
+        return 52000n;
+    }
+}
+/**
+ * 批量预估多个 ERC20 转账的 Gas Limit
+ * ✅ 选取最大值作为统一的 gas limit（确保所有转账都能成功）
+ */
+export async function estimateMaxErc20TransferGas(provider, tokenAddress, from, recipients, amounts, bufferPercent = 5) {
+    if (recipients.length === 0)
+        return 52000n;
+    // 为了减少 RPC 调用，最多预估前 3 个和最后 1 个
+    const sampleIndices = [];
+    sampleIndices.push(0); // 第一个
+    if (recipients.length > 1)
+        sampleIndices.push(Math.min(1, recipients.length - 1));
+    if (recipients.length > 2)
+        sampleIndices.push(Math.min(2, recipients.length - 1));
+    if (recipients.length > 3)
+        sampleIndices.push(recipients.length - 1); // 最后一个
+    // 去重
+    const uniqueIndices = [...new Set(sampleIndices)];
+    try {
+        const estimates = await Promise.all(uniqueIndices.map(i => estimateErc20TransferGas(provider, tokenAddress, from, recipients[i], amounts[i], bufferPercent)));
+        // 取最大值
+        const maxGas = estimates.reduce((max, gas) => gas > max ? gas : max, 0n);
+        console.log(`[estimateMaxErc20TransferGas] 样本数: ${uniqueIndices.length}, 最大 gas limit: ${maxGas}`);
+        return maxGas;
+    }
+    catch (error) {
+        console.warn(`[estimateMaxErc20TransferGas] 批量预估失败，使用默认值:`, error);
+        return 52000n;
+    }
+}
 /**
  * 计算 Gas Limit
  * - 原生代币转账：21000 gas（固定）
@@ -133,8 +197,8 @@ export function calculateGasLimit(config, isNative, hasHops, hopCount = 0) {
     if (config.gasLimit !== undefined) {
         return BigInt(config.gasLimit);
     }
-    // ✅ 原生代币: 21000, ERC20 标准 transfer: 55000（实际约 45000-52000）
-    const baseGas = isNative ? 21000 : 55000;
+    // ✅ 原生代币: 21000, ERC20 标准 transfer: 48000（USDT 最低约 46815）
+    const baseGas = isNative ? 21000 : 46815;
     // ✅ 多跳时只需要累加单次转账的 gas，不需要额外乘数
     // 每个中转钱包只执行一笔 transfer
     if (hasHops && hopCount > 0) {

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

@@ -11,6 +11,7 @@ export type FourSignConfig = {
     chainId?: number;
     prefer21000ForNative?: boolean;
     checkBnbForErc20NoHop?: boolean;
+    estimateGas?: boolean;
     customSubmitFn?: (signedTxs: string[]) => Promise<string>;
     spPrivateKey?: string;
     spMode?: 'none' | 'timestampPersonalSign' | 'concatTxHash' | 'rawTimestamp';

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

@@ -2,7 +2,7 @@ import { ethers, Wallet } from 'ethers';
 import { getOptimizedGasPrice, NonceManager } from '../../utils/bundle-helpers.js';
 import { PROFIT_CONFIG, ZERO_ADDRESS } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, getProfitRecipient } from './config.js';
-import { getErc20DecimalsMerkle as _getErc20DecimalsMerkle, generateHopWallets as _generateHopWallets, normalizeAmounts as _normalizeAmounts, batchGetBalances as _batchGetBalances, calculateGasLimit as _calculateGasLimit, isNativeTokenAddress as _isNativeTokenAddress } from './internal.js';
+import { getErc20DecimalsMerkle as _getErc20DecimalsMerkle, generateHopWallets as _generateHopWallets, normalizeAmounts as _normalizeAmounts, batchGetBalances as _batchGetBalances, calculateGasLimit as _calculateGasLimit, isNativeTokenAddress as _isNativeTokenAddress, estimateErc20TransferGas as _estimateErc20TransferGas } from './internal.js';
 // ==================== 本地利润计算（万分之三）====================
 /**
  * 计算利润金额（万分之三）
@@ -355,26 +355,45 @@ export async function disperseWithBundleMerkle(params) {
             isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum))
         ]);
         const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-        // ✅ 原生代币多跳使用 21500 gas limit（21000 + 500 余量），避免中转钱包残留 BNB
-        const hopGasLimit = isNative ? 21200n : finalGasLimit;
-        const gasFeePerHop = hopGasLimit * gasPrice;
+        // ✅ Gas limit 设置
+        // - 原生代币转账：21000（固定）
+        // - ERC20 转账：通过模拟交易获取最小 gas limit（减少中转钱包 BNB 残留）
+        const nativeTransferGasLimit = 21000n;
+        // ✅ ERC20 多跳：模拟交易获取精确的 gas limit
+        let erc20TransferGasLimit = finalGasLimit;
+        if (!isNative && config.estimateGas !== false) {
+            try {
+                // 使用第一个接收者模拟一笔转账，获取精确的 gas limit
+                const sampleAmount = ethers.parseUnits(normalizedAmounts[0], decimals);
+                const estimatedGas = await _estimateErc20TransferGas(provider, tokenAddress, mainWallet.address, recipients[0], sampleAmount, 0 // ✅ 不加缓冲，最大化减少多跳钱包残留
+                );
+                erc20TransferGasLimit = estimatedGas;
+                console.log(`[disperseWithBundleMerkle] 使用模拟估算的 ERC20 gas limit: ${erc20TransferGasLimit}`);
+            }
+            catch (error) {
+                console.warn(`[disperseWithBundleMerkle] 模拟估算失败，使用默认值:`, error);
+            }
+        }
+        // ✅ 原生代币多跳的 gas 费（每跳只需要 21000）
+        const nativeHopGasFee = nativeTransferGasLimit * gasPrice;
+        // ✅ ERC20 多跳时，中转钱包需要执行 2 笔交易（转 gas + 转 ERC20）
+        const erc20HopGasFee = erc20TransferGasLimit * gasPrice;
+        const nativeHopGasFeeForErc20 = nativeTransferGasLimit * gasPrice;
         // ✅ 优化：预先计算主钱包需要的总 nonce 数量
+        // - 原生代币多跳：主钱包只需要 1 个 nonce（一笔转账包含后续所有 gas）
+        // - ERC20 多跳：主钱包需要 2 个 nonce（转 gas + 转 ERC20）
         let mainWalletNonceCount = 0;
-        const recipientNonceNeeds = [];
         for (let i = 0; i < recipients.length; i++) {
             const hopChain = preparedHops[i];
             if (hopChain.length === 0) {
                 // 无跳转：1 个 nonce
-                recipientNonceNeeds.push(1);
                 mainWalletNonceCount += 1;
             }
             else {
                 // 有跳转：
-                // - ERC20: hopChain.length (gas 费) + 1 (主转账)
-                // - Native: 1 (主转账)
-                const nonceNeed = isNative ? 1 : (hopChain.length + 1);
-                recipientNonceNeeds.push(nonceNeed);
-                mainWalletNonceCount += nonceNeed;
+                // - Native: 1（一笔转账）
+                // - ERC20: 2（转 gas + 转 ERC20）
+                mainWalletNonceCount += isNative ? 1 : 2;
             }
         }
         // 利润交易需要额外 1 个 nonce
@@ -444,32 +463,14 @@ export async function disperseWithBundleMerkle(params) {
             // 有跳转
             const fullChain = [mainWallet, ...hopChain.map(pk => new Wallet(pk, provider))];
             const addresses = [...fullChain.map(w => w.address), finalRecipient];
-            // ERC20 多跳：先给中转钱包转 gas 费
-            if (!isNative) {
-                for (let j = 0; j < hopChain.length; j++) {
-                    const nonce = allMainNonces[mainNonceIdx++];
-                    txsToSign.push({
-                        wallet: mainWallet,
-                        tx: {
-                            to: fullChain[j + 1].address,
-                            value: gasFeePerHop,
-                            nonce,
-                            gasPrice,
-                            gasLimit: nativeGasLimit,
-                            chainId: chainIdNum,
-                            type: txType
-                        }
-                    });
-                }
-            }
-            // 执行主要的转账链
-            for (let j = 0; j < addresses.length - 1; j++) {
-                const fromWallet = fullChain[j];
-                const toAddress = addresses[j + 1];
-                const nonce = j === 0 ? allMainNonces[mainNonceIdx++] : 0;
-                if (isNative) {
+            if (isNative) {
+                // ========== 原生代币多跳：gas 包含在转账金额中逐层传递 ==========
+                for (let j = 0; j < addresses.length - 1; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1];
+                    const nonce = j === 0 ? allMainNonces[mainNonceIdx++] : 0;
                     const remainingHops = addresses.length - 2 - j;
-                    const additionalGas = gasFeePerHop * BigInt(remainingHops);
+                    const additionalGas = nativeHopGasFee * BigInt(remainingHops);
                     const transferValue = amountWei + additionalGas;
                     txsToSign.push({
                         wallet: fromWallet,
@@ -478,27 +479,112 @@ export async function disperseWithBundleMerkle(params) {
                             value: transferValue,
                             nonce,
                             gasPrice,
-                            gasLimit: hopGasLimit, // ✅ 原生代币使用精确的 21000
+                            gasLimit: nativeTransferGasLimit,
                             chainId: chainIdNum,
                             type: txType
                         }
                     });
                 }
-                else {
-                    const data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
-                    txsToSign.push({
-                        wallet: fromWallet,
-                        tx: {
-                            to: tokenAddress,
-                            data,
-                            value: 0n,
-                            nonce,
-                            gasPrice,
-                            gasLimit: hopGasLimit, // ✅ ERC20 使用优化后的 60500
-                            chainId: chainIdNum,
-                            type: txType
-                        }
-                    });
+            }
+            else {
+                // ========== ERC20 多跳：gas 也逐层传递（保护隐私）==========
+                // 计算每个中转钱包需要的 gas（从后往前）
+                // - 最后一个中转钱包：只需要 ERC20 转账的 gas
+                // - 其他中转钱包：需要 转 gas 的 gas + ERC20 转账的 gas + 后续所有的 gas
+                const hopGasNeeds = [];
+                for (let j = hopChain.length - 1; j >= 0; j--) {
+                    if (j === hopChain.length - 1) {
+                        // 最后一个中转钱包：只需要 ERC20 转账的 gas
+                        hopGasNeeds.unshift(erc20HopGasFee);
+                    }
+                    else {
+                        // 其他中转钱包：转 gas(21000) + 转 ERC20 + 后续的 gas
+                        const nextHopGas = hopGasNeeds[0];
+                        hopGasNeeds.unshift(nativeHopGasFeeForErc20 + erc20HopGasFee + nextHopGas);
+                    }
+                }
+                // 第一步：主钱包给第一个中转钱包转 gas（包含所有后续的 gas）
+                const totalGasForFirstHop = hopGasNeeds[0];
+                txsToSign.push({
+                    wallet: mainWallet,
+                    tx: {
+                        to: fullChain[1].address,
+                        value: totalGasForFirstHop,
+                        nonce: allMainNonces[mainNonceIdx++],
+                        gasPrice,
+                        gasLimit: nativeTransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第二步：主钱包给第一个中转钱包转 ERC20
+                const mainToFirstHopData = iface.encodeFunctionData('transfer', [fullChain[1].address, amountWei]);
+                txsToSign.push({
+                    wallet: mainWallet,
+                    tx: {
+                        to: tokenAddress,
+                        data: mainToFirstHopData,
+                        value: 0n,
+                        nonce: allMainNonces[mainNonceIdx++],
+                        gasPrice,
+                        gasLimit: erc20TransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第三步：中转钱包逐层传递（gas 和 ERC20）
+                for (let j = 1; j < fullChain.length; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1]; // 下一个地址（可能是中转钱包或最终接收者）
+                    const isLastHop = j === fullChain.length - 1;
+                    if (!isLastHop) {
+                        // 非最后一个中转钱包：先转 gas 给下一个中转钱包
+                        const gasToTransfer = hopGasNeeds[j]; // 下一个中转钱包需要的 gas
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: toAddress,
+                                value: gasToTransfer,
+                                nonce: 0, // 中转钱包的第一笔交易
+                                gasPrice,
+                                gasLimit: nativeTransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                        // 再转 ERC20
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 1, // 中转钱包的第二笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                    else {
+                        // 最后一个中转钱包：只转 ERC20 给最终接收者
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 0, // 最后一个中转钱包只有一笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
                 }
             }
         }
@@ -915,9 +1001,31 @@ export async function sweepWithBundleMerkle(params) {
             isNative ? Promise.resolve([]) : _batchGetBalances(provider, sourceAddresses)
         ]);
         const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-        // ✅ 原生代币多跳使用 21500 gas limit（21000 + 500 余量），避免中转钱包残留 BNB
-        const hopGasLimit = isNative ? 21500n : finalGasLimit;
-        const gasFeePerHop = hopGasLimit * gasPrice;
+        // ✅ Gas limit 设置（与分散函数保持一致）
+        const nativeTransferGasLimit = 21000n;
+        // ✅ ERC20 多跳：模拟交易获取精确的 gas limit
+        let erc20TransferGasLimit = finalGasLimit;
+        if (!isNative && config.estimateGas !== false) {
+            try {
+                // 找到第一个有余额的钱包来模拟转账
+                const firstWithBalance = balances.findIndex(b => b > 0n);
+                if (firstWithBalance >= 0) {
+                    const sampleAmount = balances[firstWithBalance] > 0n ? balances[firstWithBalance] / 2n : 1n;
+                    const estimatedGas = await _estimateErc20TransferGas(provider, tokenAddress, sourceAddresses[firstWithBalance], target, sampleAmount, 0 // ✅ 不加缓冲，最大化减少多跳钱包残留
+                    );
+                    erc20TransferGasLimit = estimatedGas;
+                    console.log(`[sweepWithBundleMerkle] 使用模拟估算的 ERC20 gas limit: ${erc20TransferGasLimit}`);
+                }
+            }
+            catch (error) {
+                console.warn(`[sweepWithBundleMerkle] 模拟估算失败，使用默认值:`, error);
+            }
+        }
+        // ✅ 原生代币多跳的 gas 费（每跳只需要 21000）
+        const nativeHopGasFee = nativeTransferGasLimit * gasPrice;
+        // ✅ ERC20 多跳时，中转钱包需要执行 2 笔交易（转 gas + 转 ERC20）
+        const erc20HopGasFee = erc20TransferGasLimit * gasPrice;
+        const nativeHopGasFeeForErc20 = nativeTransferGasLimit * gasPrice;
         const nonceManager = new NonceManager(provider);
         // ✅ 用于记录每个钱包的归集金额
         const sweepAmounts = new Array(sourceWallets.length).fill(0n);
@@ -1019,7 +1127,8 @@ export async function sweepWithBundleMerkle(params) {
             const ratioForI = getRatioForI(i);
             const amountStrForI = getAmountStrForI(i);
             if (isNative) {
-                const totalGasCost = finalGasLimit * gasPrice * BigInt(hopChain.length + 1);
+                // 原生代币多跳每跳只需要 21000 gas
+                const totalGasCost = nativeTransferGasLimit * gasPrice * BigInt(hopChain.length + 1);
                 if (ratioForI !== undefined) {
                     const want = (bal * BigInt(ratioForI)) / 100n;
                     const maxSendable = bal > totalGasCost ? (bal - totalGasCost) : 0n;
@@ -1034,7 +1143,13 @@ export async function sweepWithBundleMerkle(params) {
             }
             else {
                 const bnbBal = bnbBalances[i];
-                const bnbNeeded = (gasFeePerHop * BigInt(hopChain.length)) + (finalGasLimit * gasPrice);
+                // 计算 ERC20 多跳所需的 BNB（逐层传递模式）：
+                // - 源钱包执行 2 笔交易的 gas（转 gas 21000 + 转 ERC20）
+                // - 源钱包转给第一个中转钱包的 gas（包含后续所有）
+                // 简化计算：每个中转钱包 ≈ (21000 + erc20GasLimit) * gasPrice
+                const sourceGas = (nativeTransferGasLimit + erc20TransferGasLimit) * gasPrice;
+                const hopGas = (nativeHopGasFeeForErc20 + erc20HopGasFee) * BigInt(hopChain.length);
+                const bnbNeeded = sourceGas + hopGas;
                 if (bnbBal < bnbNeeded && skipIfInsufficient)
                     continue;
                 if (ratioForI !== undefined) {
@@ -1056,9 +1171,9 @@ export async function sweepWithBundleMerkle(params) {
         }
         // ========== 第5步：计算每个有跳转钱包需要的 nonce 数量并批量获取 ==========
         // 每个源钱包需要的 nonce 数量：
-        // - ERC20: hopChain.length (gas费交易) + 1 (主转账)
-        // - Native: 1 (主转账)
-        const hopNonceNeeds = hopTxDataList.map(d => isNative ? 1 : d.hopChain.length + 1);
+        // - Native: 1（一笔转账包含后续所有 gas）
+        // - ERC20: 2（转 gas + 转 ERC20）
+        const hopNonceNeeds = hopTxDataList.map(() => isNative ? 1 : 2);
         const hopSourceWallets = hopTxDataList.map(d => d.sourceWallet);
         // ✅ 批量获取所有有跳转钱包的 nonces
         const hopNoncesFlat = [];
@@ -1074,32 +1189,14 @@ export async function sweepWithBundleMerkle(params) {
             const nonceCount = hopNonceNeeds[dataIdx];
             const nonces = hopNoncesFlat.slice(nonceOffset, nonceOffset + nonceCount);
             nonceOffset += nonceCount;
-            let nonceIdx = 0;
-            // ERC20 多跳：先给中转钱包转 gas 费
-            if (!isNative) {
-                for (let j = 0; j < hopChain.length; j++) {
-                    hopTxsToSign.push({
-                        wallet: sourceWallet,
-                        tx: {
-                            to: fullChain[j + 1].address,
-                            value: gasFeePerHop,
-                            nonce: nonces[nonceIdx++],
-                            gasPrice,
-                            gasLimit: nativeGasLimit,
-                            chainId: chainIdNum,
-                            type: txType
-                        }
-                    });
-                }
-            }
-            // 执行主要的归集链
-            for (let j = 0; j < addresses.length - 1; j++) {
-                const fromWallet = fullChain[j];
-                const toAddress = addresses[j + 1];
-                const nonce = j === 0 ? nonces[nonceIdx++] : 0;
-                if (isNative) {
+            if (isNative) {
+                // ========== 原生代币多跳：gas 包含在转账金额中逐层传递 ==========
+                for (let j = 0; j < addresses.length - 1; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1];
+                    const nonce = j === 0 ? nonces[0] : 0;
                     const remainingHops = addresses.length - 2 - j;
-                    const additionalGas = gasFeePerHop * BigInt(remainingHops);
+                    const additionalGas = nativeHopGasFee * BigInt(remainingHops);
                     const valueToTransfer = toSend + additionalGas;
                     hopTxsToSign.push({
                         wallet: fromWallet,
@@ -1108,27 +1205,110 @@ export async function sweepWithBundleMerkle(params) {
                             value: valueToTransfer,
                             nonce,
                             gasPrice,
-                            gasLimit: hopGasLimit, // ✅ 原生代币使用精确的 21000
+                            gasLimit: nativeTransferGasLimit,
                             chainId: chainIdNum,
                             type: txType
                         }
                     });
                 }
-                else {
-                    const data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
-                    hopTxsToSign.push({
-                        wallet: fromWallet,
-                        tx: {
-                            to: tokenAddress,
-                            data,
-                            value: 0n,
-                            nonce,
-                            gasPrice,
-                            gasLimit: hopGasLimit, // ✅ ERC20 使用优化后的 60500
-                            chainId: chainIdNum,
-                            type: txType
-                        }
-                    });
+            }
+            else {
+                // ========== ERC20 多跳：gas 也逐层传递（保护隐私）==========
+                // 计算每个中转钱包需要的 gas（从后往前）
+                const hopGasNeeds = [];
+                for (let j = hopChain.length - 1; j >= 0; j--) {
+                    if (j === hopChain.length - 1) {
+                        // 最后一个中转钱包：只需要 ERC20 转账的 gas
+                        hopGasNeeds.unshift(erc20HopGasFee);
+                    }
+                    else {
+                        // 其他中转钱包：转 gas(21000) + 转 ERC20 + 后续的 gas
+                        const nextHopGas = hopGasNeeds[0];
+                        hopGasNeeds.unshift(nativeHopGasFeeForErc20 + erc20HopGasFee + nextHopGas);
+                    }
+                }
+                // 第一步：源钱包给第一个中转钱包转 gas（包含所有后续的 gas）
+                const totalGasForFirstHop = hopGasNeeds[0];
+                hopTxsToSign.push({
+                    wallet: sourceWallet,
+                    tx: {
+                        to: fullChain[1].address,
+                        value: totalGasForFirstHop,
+                        nonce: nonces[0],
+                        gasPrice,
+                        gasLimit: nativeTransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第二步：源钱包给第一个中转钱包转 ERC20
+                const sourceToFirstHopData = iface.encodeFunctionData('transfer', [fullChain[1].address, toSend]);
+                hopTxsToSign.push({
+                    wallet: sourceWallet,
+                    tx: {
+                        to: tokenAddress,
+                        data: sourceToFirstHopData,
+                        value: 0n,
+                        nonce: nonces[1],
+                        gasPrice,
+                        gasLimit: erc20TransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第三步：中转钱包逐层传递（gas 和 ERC20）
+                for (let j = 1; j < fullChain.length; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1]; // 下一个地址（可能是中转钱包或最终目标）
+                    const isLastHop = j === fullChain.length - 1;
+                    if (!isLastHop) {
+                        // 非最后一个中转钱包：先转 gas 给下一个中转钱包
+                        const gasToTransfer = hopGasNeeds[j]; // 下一个中转钱包需要的 gas
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: toAddress,
+                                value: gasToTransfer,
+                                nonce: 0, // 中转钱包的第一笔交易
+                                gasPrice,
+                                gasLimit: nativeTransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                        // 再转 ERC20
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 1, // 中转钱包的第二笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                    else {
+                        // 最后一个中转钱包：只转 ERC20 给最终目标
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 0, // 最后一个中转钱包只有一笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
                 }
             }
         }

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

@@ -137,8 +137,8 @@ function calculateGasLimit(config, isNative, hasHops, _hopCount = 0) {
     if (config.gasLimit !== undefined) {
         return BigInt(config.gasLimit);
     }
-    // ✅ 原生代币: 21000, ERC20 标准 transfer: 55000（实际约 45000-52000）
-    const baseGas = isNative ? 21000 : 55000;
+    // ✅ 原生代币: 21000, ERC20 标准 transfer: 48000（USDT 最低约 46815）
+    const baseGas = isNative ? 21000 : 48000;
     // ✅ 多跳时每个中转钱包只执行一笔 transfer，使用较小的安全系数
     const multiplier = config.gasLimitMultiplier ?? 1.1;
     return BigInt(Math.ceil(baseGas * multiplier));

package/package.json

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