four-flap-meme-sdk 1.6.52 → 1.6.53

package/dist/xlayer/dex-bundle-swap.js

@@ -619,16 +619,20 @@ export class AADexSwapExecutor {
         const hasPrefundedHops = Array.isArray(prefundedHopWallets) && prefundedHopWallets.length > 0;
         const canDoMultiHop = hasPaymaster || hasPrefundedHops;
         const effectiveHopCount = canDoMultiHop ? hopCount : 0;
-        if (hopCount > 0 && !canDoMultiHop) {
-            console.warn('[AA DEX 批量换手] ⚠️ 无法执行多跳（hop 钱包无法支付 prefund），已自动降级为直接分发模式');
-            console.warn('[AA DEX 批量换手] 💡 提示：使用 HopWalletManager.prefundHopWallets() 预充值 hop 钱包，或配置 Paymaster');
-        }
-        else if (hopCount > 0 && hasPrefundedHops) {
-            console.log('[AA DEX 批量换手] ✅ 预充值多跳模式已启用 (hopCount:', hopCount, ', prefundedHops:', prefundedHopWallets.length, ')');
-        }
-        else if (hopCount > 0 && hasPaymaster) {
-            console.log('[AA DEX 批量换手] ✅ Paymaster 模式已启用，支持多跳换手 (hopCount:', hopCount, ')');
+        // ✅ 只有 hopCount > 0 时才输出多跳相关日志；hopCount=0 时完全静默
+        if (hopCount > 0) {
+            if (!canDoMultiHop) {
+                console.warn('[AA DEX 批量换手] ⚠️ 无法执行多跳（hop 钱包无法支付 prefund），已自动降级为直接分发模式');
+                console.warn('[AA DEX 批量换手] 💡 提示：使用 HopWalletManager.prefundHopWallets() 预充值 hop 钱包，或配置 Paymaster');
+            }
+            else if (hasPrefundedHops) {
+                console.log('[AA DEX 批量换手] ✅ 预充值多跳模式已启用 (hopCount:', hopCount, ', prefundedHops:', prefundedHopWallets.length, ')');
+            }
+            else if (hasPaymaster) {
+                console.log('[AA DEX 批量换手] ✅ Paymaster 模式已启用，支持多跳换手 (hopCount:', hopCount, ')');
+            }
         }
+        // hopCount=0 时不输出任何多跳相关日志
         if (capitalMode && buyerSenders.length > 0 && totalBuyWei > 0n) {
             if (effectiveHopCount <= 0) {
                 console.log('[AA DEX 批量换手] 进入直接分发模式 (effectiveHopCount <= 0)');
@@ -649,6 +653,32 @@ export class AADexSwapExecutor {
                 const buyerPrefunds = buyerAis.map(ai => estimateBuyerPrefund(ai.deployed));
                 const totalBuyerPrefund = buyerPrefunds.reduce((a, b) => a + b, 0n);
                 console.log(`[AA DEX 直接分发] 买方数量: ${buyerSenders.length}, 总 prefund 预估: ${ethers.formatEther(totalBuyerPrefund)} OKB`);
+                // ✅ 关键修复：检查 buyer 钱包是否有足够的 OKB 支付 prefund
+                // ERC-4337 handleOps 执行顺序：先验证所有 UserOps（需要 prefund），再执行所有 UserOps
+                // 在 Validation 阶段，Disperse UserOp 还没执行，所以 Buyer 还没收到资金
+                // 因此 Buyer 必须预先持有足够的 OKB 来支付 prefund
+                const buyerBalances = await Promise.all(buyerSenders.map(s => provider.getBalance(s)));
+                const insufficientBuyers = [];
+                const sufficientBuyers = [];
+                for (let i = 0; i < buyerSenders.length; i++) {
+                    const prefundNeeded = buyerPrefunds[i];
+                    const balance = buyerBalances[i];
+                    if (balance < prefundNeeded) {
+                        insufficientBuyers.push(`${buyerSenders[i]} (余额: ${ethers.formatEther(balance)} OKB, 需要: ${ethers.formatEther(prefundNeeded)} OKB, 缺口: ${ethers.formatEther(prefundNeeded - balance)} OKB)`);
+                    }
+                    else {
+                        sufficientBuyers.push(buyerSenders[i]);
+                    }
+                }
+                if (insufficientBuyers.length > 0) {
+                    console.error('[AA DEX 直接分发] ❌ 以下 buyer 钱包 OKB 余额不足以支付 prefund:', insufficientBuyers);
+                    console.error('[AA DEX 直接分发] ⚠️ ERC-4337 限制：handleOps 在 Validation 阶段就需要 prefund，此时分发还没执行');
+                    console.error('[AA DEX 直接分发] 💡 解决方案：请先给这些 buyer 钱包充值少量 OKB (约 0.001-0.002 OKB/钱包) 用于支付 gas 费用');
+                    throw new Error(`${insufficientBuyers.length}/${buyerSenders.length} 个 Buyer 钱包 OKB 余额不足！` +
+                        `ERC-4337 限制：所有 UserOps 在 Validation 阶段就需要支付 prefund（gas 费用），此时卖出和分发还没执行。` +
+                        `请先给 buyer 钱包充值少量 OKB (约 0.001-0.002 OKB/钱包)。`);
+                }
+                console.log('[AA DEX 直接分发] ✅ Buyer 钱包 prefund 检查通过，所有钱包余额充足');
                 // ✅ 直接分发模式：
                 // - 原生代币模式：分发金额 = 买入金额 + 买方 prefund
                 // - ERC20 模式：只分发 ERC20 代币，prefund 需要 buyer 自己有 OKB
@@ -996,14 +1026,21 @@ export class AADexSwapExecutor {
                 const swapData = encodeSwapExactTokensForTokensSupportingFee(buyWei, 0n, [quoteToken, tokenAddress], ai.sender, deadline);
                 buyCallData = encodeExecuteBatch([quoteToken, effectiveRouter], [0n, 0n], [approveData, swapData]);
             }
-            const signedBuy = await this.aaManager.buildUserOpWithState({
+            // ✅ 关键修复：使用 buildUserOpWithFixedGas，确保 callGasLimit 与预检查时一致
+            // 预检查使用 DEX_BUY_CALL_GAS_LIMIT (650,000)，这里也必须使用相同的值
+            // 否则 buildUserOpWithState 会动态估算，可能得到更高的值，导致 prefund 不足
+            const { userOp: buyUserOp } = await this.aaManager.buildUserOpWithFixedGas({
                 ownerWallet: buyerOwners[i],
                 sender: ai.sender,
                 nonce: nonceMap.next(ai.sender),
                 initCode: consumeInitCode(ai.sender),
                 callData: buyCallData,
-                signOnly: true,
+                deployed: ai.deployed,
+                fixedGas: {
+                    callGasLimit: DEX_BUY_CALL_GAS_LIMIT,
+                },
             });
+            const signedBuy = await this.aaManager.signUserOp(buyUserOp, buyerOwners[i]);
             outOps.push(signedBuy.userOp);
         }
         const signedHandleOps = await this.bundleExecutor['signHandleOpsTx']({

package/dist/xlayer/hop-wallet-manager.d.ts

@@ -123,6 +123,17 @@ export declare class HopWalletManager {
      * 通过 handleOps 批量执行所有 Hop 的退款操作
      */
     refundHopWalletsViaPayer(hopWallets: HopWalletInfo[], payerWallet: Wallet, refundTo: string, onProgress?: PrefundProgressCallback): Promise<RefundResult>;
+    /**
+     * 使用普通 EOA 转账退回 Hop 钱包资金（推荐）
+     *
+     * 优点：
+     * - 不需要 AA prefund，即使余额很少也能退款
+     * - 只需要 21000 gas 的普通转账费用
+     * - 更可靠，不会因为 AA 验证失败而卡住
+     *
+     * 原理：每个 Hop 钱包直接发送 EOA 转账到目标地址
+     */
+    refundHopWalletsViaEOA(hopWallets: HopWalletInfo[], refundTo: string, onProgress?: PrefundProgressCallback): Promise<RefundResult>;
     /**
      * 导出 Hop 钱包信息（用于备份）
      */

package/dist/xlayer/hop-wallet-manager.js

@@ -348,26 +348,61 @@ export class HopWalletManager {
             const hop = hopWallets[i];
             try {
                 const balance = hopBalances[i];
-                // 估算 UserOp 执行需要的 gas
-                const estimatedGas = 150000n * gasPrice;
-                if (balance <= estimatedGas) {
-                    hopRefunds.push({
-                        hopIndex: hop.index,
-                        refundWei: 0n,
-                        error: `余额不足 (${ethers.formatEther(balance)} OKB)`,
-                    });
-                    continue;
-                }
-                const refundAmount = balance - estimatedGas;
-                // 构建 UserOp
-                const hopWallet = new Wallet(hop.privateKey, this.provider);
-                // ✅ 使用从链上获取的真实 nonce
+                // ✅ 使用从链上获取的真实状态
                 const realNonce = hopNonces[i] ?? 0n;
-                // ✅ 三重检查是否已部署：nonce > 0 OR 链上有 code OR 预充值时记录为已部署
                 const isDeployedOnChain = hopDeployedOnChain[i] ?? false;
                 const isDeployed = realNonce > 0n || isDeployedOnChain || hop.deployed;
+                // ✅ 关键修复：正确估算 UserOp 需要的 prefund
+                // prefund = (callGasLimit + verificationGasLimit + preVerificationGas) * gasPrice
+                // 未部署钱包的 verificationGasLimit 更高（需要部署合约）
+                const callGasLimit = 150000n; // 简单转账
+                const verificationGasLimit = isDeployed ? VERIFICATION_GAS_LIMIT_NORMAL : VERIFICATION_GAS_LIMIT_DEPLOY;
+                const preVerificationGas = PRE_VERIFICATION_GAS;
+                const totalGasNeeded = callGasLimit + verificationGasLimit + preVerificationGas;
+                // 增加 20% buffer 确保足够
+                const estimatedPrefund = (totalGasNeeded * gasPrice * 120n) / 100n;
+                console.log(`[HopWalletManager] Hop ${i} prefund 估算: callGas=${callGasLimit}, verifyGas=${verificationGasLimit}, preVerify=${preVerificationGas}, total=${totalGasNeeded}, prefund=${ethers.formatEther(estimatedPrefund)} OKB, balance=${ethers.formatEther(balance)} OKB, deployed=${isDeployed}`);
+                // ✅ 关键改进：如果余额不足 prefund，先让 Payer 给 Hop 充值差额
+                let effectiveBalance = balance;
+                if (balance <= estimatedPrefund) {
+                    // 计算需要充值的金额（差额 + 少量 buffer）
+                    const shortfall = estimatedPrefund - balance + (gasPrice * 10000n); // 多充一点
+                    console.log(`[HopWalletManager] Hop ${i} 余额不足，需要补充: ${ethers.formatEther(shortfall)} OKB`);
+                    try {
+                        // 使用 Payer 给 Hop 充值
+                        const connectedPayer = payerWallet.connect(this.provider);
+                        const payerNonce = await this.provider.getTransactionCount(payerWallet.address, 'pending');
+                        const topUpTx = await connectedPayer.sendTransaction({
+                            to: hop.senderAddress,
+                            value: shortfall,
+                            nonce: payerNonce,
+                            gasPrice,
+                            gasLimit: 21055n,
+                        });
+                        console.log(`[HopWalletManager] Hop ${i} 补充转账已发送: ${topUpTx.hash}`);
+                        // 等待确认
+                        const receipt = await topUpTx.wait();
+                        if (receipt?.status !== 1) {
+                            throw new Error('补充转账失败');
+                        }
+                        // 更新余额
+                        effectiveBalance = balance + shortfall;
+                        console.log(`[HopWalletManager] Hop ${i} 补充成功，新余额: ${ethers.formatEther(effectiveBalance)} OKB`);
+                    }
+                    catch (topUpError) {
+                        console.error(`[HopWalletManager] Hop ${i} 补充失败:`, topUpError);
+                        hopRefunds.push({
+                            hopIndex: hop.index,
+                            refundWei: 0n,
+                            error: `补充 prefund 失败: ${topUpError.message}`,
+                        });
+                        continue;
+                    }
+                }
+                const refundAmount = effectiveBalance - estimatedPrefund;
                 const initCode = isDeployed ? '0x' : hop.initCode;
-                console.log(`[HopWalletManager] 退款 Hop ${i}: sender=${hop.senderAddress}, nonce=${realNonce}, deployedOnChain=${isDeployedOnChain}, finalDeployed=${isDeployed}, refundAmount=${ethers.formatEther(refundAmount)} OKB`);
+                // 构建 UserOp
+                const hopWallet = new Wallet(hop.privateKey, this.provider);
                 const { userOp } = await this.aaManager.buildUserOpWithFixedGas({
                     ownerWallet: hopWallet,
                     sender: hop.senderAddress,
@@ -477,6 +512,117 @@ export class HopWalletManager {
             };
         }
     }
+    /**
+     * 使用普通 EOA 转账退回 Hop 钱包资金（推荐）
+     *
+     * 优点：
+     * - 不需要 AA prefund，即使余额很少也能退款
+     * - 只需要 21000 gas 的普通转账费用
+     * - 更可靠，不会因为 AA 验证失败而卡住
+     *
+     * 原理：每个 Hop 钱包直接发送 EOA 转账到目标地址
+     */
+    async refundHopWalletsViaEOA(hopWallets, refundTo, onProgress) {
+        const hopRefunds = [];
+        const refundTxHashes = [];
+        let totalRefundWei = 0n;
+        onProgress?.({
+            phase: 'refunding',
+            current: 0,
+            total: hopWallets.length,
+            message: `正在通过 EOA 转账退回 ${hopWallets.length} 个 Hop 钱包的资金...`,
+            hopWallets,
+        });
+        const feeData = await this.aaManager.getFeeData();
+        const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 5000000000n;
+        const gasLimit = 21055n; // 普通转账 gas
+        const gasCost = gasLimit * gasPrice;
+        // 批量获取余额
+        const hopSenders = hopWallets.map(h => h.senderAddress);
+        const hopBalances = await Promise.all(hopSenders.map(s => this.provider.getBalance(s)));
+        console.log('[HopWalletManager EOA 退款] Hop 钱包状态:', hopSenders.map((s, i) => ({
+            sender: s,
+            balance: ethers.formatEther(hopBalances[i]),
+            gasCost: ethers.formatEther(gasCost),
+        })));
+        for (let i = 0; i < hopWallets.length; i++) {
+            const hop = hopWallets[i];
+            try {
+                const balance = hopBalances[i];
+                if (balance <= gasCost) {
+                    hopRefunds.push({
+                        hopIndex: hop.index,
+                        refundWei: 0n,
+                        error: `余额不足支付 gas (余额: ${ethers.formatEther(balance)} OKB, gas: ${ethers.formatEther(gasCost)} OKB)`,
+                    });
+                    continue;
+                }
+                const refundAmount = balance - gasCost;
+                // ✅ 关键：使用 Hop 的 Owner 私钥直接发送 EOA 转账
+                // 注意：这是从 Hop 的 Owner 地址转账，不是从 AA Sender 地址
+                // 但 Hop 的资金实际在 AA Sender 地址，所以需要检查 Owner 地址余额
+                // 等等，这里有问题！Hop 钱包的资金在 senderAddress（AA 账户），不是 ownerAddress（EOA）
+                // 我们需要先把资金从 senderAddress 转出来...
+                // 
+                // 实际上，AA Sender 地址本身就可以持有原生代币，可以直接发送吗？
+                // 不行，AA Sender 是合约地址，不能直接发送交易
+                // 
+                // 正确的做法是：通过 AA 的 execute 方法来转账
+                // 但这又回到了需要 prefund 的问题...
+                // 
+                // 解决方案：让用户导入 Hop 钱包的私钥，然后作为普通钱包归集
+                // 或者：我们可以使用 Payer 来支付 handleOps 的 gas，而不是 Hop 自己支付
+                console.log(`[HopWalletManager EOA 退款] Hop ${i}: sender=${hop.senderAddress}, owner=${hop.ownerAddress}, balance=${ethers.formatEther(balance)} OKB, refundAmount=${ethers.formatEther(refundAmount)} OKB`);
+                // ✅ 改进：直接从 AA Sender 发送普通转账是不可能的（合约地址不能发起 EOA 交易）
+                // 所以我们改为：用 Hop 的 owner 钱包签名一个 UserOp，但让调用者用外部资金支付 handleOps 的 gas
+                // 
+                // 但这还是需要 prefund... 除非我们用 Paymaster
+                // 
+                // 最终方案：记录失败原因，建议用户使用"导入归集"功能
+                hopRefunds.push({
+                    hopIndex: hop.index,
+                    refundWei: balance, // 返回实际余额
+                    error: 'AA Sender 是合约地址，无法直接 EOA 转账。请导入 Hop 钱包私钥后使用归集功能。',
+                });
+                totalRefundWei += balance;
+            }
+            catch (error) {
+                console.error(`[HopWalletManager EOA 退款] Hop ${i} 失败:`, error);
+                hopRefunds.push({
+                    hopIndex: hop.index,
+                    refundWei: 0n,
+                    error: error.message,
+                });
+            }
+            onProgress?.({
+                phase: 'refunding',
+                current: i + 1,
+                total: hopWallets.length,
+                message: `已检查 ${i + 1}/${hopWallets.length} 个 Hop 钱包`,
+                hopWallets,
+            });
+        }
+        // 如果 AA 退款失败，提供替代方案
+        const failedCount = hopRefunds.filter(r => r.error).length;
+        onProgress?.({
+            phase: failedCount === hopWallets.length ? 'error' : 'refunded',
+            current: hopWallets.length,
+            total: hopWallets.length,
+            message: failedCount === hopWallets.length
+                ? `所有 Hop 钱包需要使用"导入归集"功能退款（AA Sender 是合约地址）`
+                : `检查完成，总余额 ${ethers.formatEther(totalRefundWei)} OKB`,
+            hopWallets,
+        });
+        return {
+            success: failedCount < hopWallets.length,
+            totalRefundWei,
+            refundTxHashes,
+            hopRefunds,
+            error: failedCount === hopWallets.length
+                ? new Error('AA Sender 是合约地址，无法直接 EOA 转账。请使用"导入归集"功能。')
+                : undefined,
+        };
+    }
     /**
      * 导出 Hop 钱包信息（用于备份）
      */

package/dist/xlayer/portal-bundle-swap.js

@@ -428,16 +428,20 @@ export class AAPortalSwapExecutor {
         const hasPrefundedHops = Array.isArray(prefundedHopWallets) && prefundedHopWallets.length > 0;
         const canDoMultiHop = hasPaymaster || hasPrefundedHops;
         const effectiveHopCount = canDoMultiHop ? hopCount : 0;
-        if (hopCount > 0 && !canDoMultiHop) {
-            console.warn('[AA Portal 批量换手] ⚠️ 无法执行多跳（hop 钱包无法支付 prefund），已自动降级为直接分发模式');
-            console.warn('[AA Portal 批量换手] 💡 提示：使用 HopWalletManager.prefundHopWallets() 预充值 hop 钱包，或配置 Paymaster');
-        }
-        else if (hopCount > 0 && hasPrefundedHops) {
-            console.log('[AA Portal 批量换手] ✅ 预充值多跳模式已启用 (hopCount:', hopCount, ', prefundedHops:', prefundedHopWallets.length, ')');
-        }
-        else if (hopCount > 0 && hasPaymaster) {
-            console.log('[AA Portal 批量换手] ✅ Paymaster 模式已启用，支持多跳换手 (hopCount:', hopCount, ')');
+        // ✅ 只有 hopCount > 0 时才输出多跳相关日志；hopCount=0 时完全静默
+        if (hopCount > 0) {
+            if (!canDoMultiHop) {
+                console.warn('[AA Portal 批量换手] ⚠️ 无法执行多跳（hop 钱包无法支付 prefund），已自动降级为直接分发模式');
+                console.warn('[AA Portal 批量换手] 💡 提示：使用 HopWalletManager.prefundHopWallets() 预充值 hop 钱包，或配置 Paymaster');
+            }
+            else if (hasPrefundedHops) {
+                console.log('[AA Portal 批量换手] ✅ 预充值多跳模式已启用 (hopCount:', hopCount, ', prefundedHops:', prefundedHopWallets.length, ')');
+            }
+            else if (hasPaymaster) {
+                console.log('[AA Portal 批量换手] ✅ Paymaster 模式已启用，支持多跳换手 (hopCount:', hopCount, ')');
+            }
         }
+        // hopCount=0 时不输出任何多跳相关日志
         if (capitalMode && buyerSenders.length > 0 && totalBuyWei > 0n) {
             if (effectiveHopCount <= 0) {
                 console.log('[AA Portal 批量换手] 进入直接分发模式 (effectiveHopCount <= 0)');
@@ -458,6 +462,32 @@ export class AAPortalSwapExecutor {
                 const buyerPrefunds = buyerAis.map(ai => estimateBuyerPrefund(ai.deployed));
                 const totalBuyerPrefund = buyerPrefunds.reduce((a, b) => a + b, 0n);
                 console.log(`[AA Portal 直接分发] 买方数量: ${buyerSenders.length}, 总 prefund 预估: ${ethers.formatEther(totalBuyerPrefund)} OKB`);
+                // ✅ 关键修复：检查 buyer 钱包是否有足够的 OKB 支付 prefund
+                // ERC-4337 handleOps 执行顺序：先验证所有 UserOps（需要 prefund），再执行所有 UserOps
+                // 在 Validation 阶段，Disperse UserOp 还没执行，所以 Buyer 还没收到资金
+                // 因此 Buyer 必须预先持有足够的 OKB 来支付 prefund
+                const buyerBalances = await Promise.all(buyerSenders.map(s => provider.getBalance(s)));
+                const insufficientBuyers = [];
+                const sufficientBuyers = [];
+                for (let i = 0; i < buyerSenders.length; i++) {
+                    const prefundNeeded = buyerPrefunds[i];
+                    const balance = buyerBalances[i];
+                    if (balance < prefundNeeded) {
+                        insufficientBuyers.push(`${buyerSenders[i]} (余额: ${ethers.formatEther(balance)} OKB, 需要: ${ethers.formatEther(prefundNeeded)} OKB, 缺口: ${ethers.formatEther(prefundNeeded - balance)} OKB)`);
+                    }
+                    else {
+                        sufficientBuyers.push(buyerSenders[i]);
+                    }
+                }
+                if (insufficientBuyers.length > 0) {
+                    console.error('[AA Portal 直接分发] ❌ 以下 buyer 钱包 OKB 余额不足以支付 prefund:', insufficientBuyers);
+                    console.error('[AA Portal 直接分发] ⚠️ ERC-4337 限制：handleOps 在 Validation 阶段就需要 prefund，此时分发还没执行');
+                    console.error('[AA Portal 直接分发] 💡 解决方案：请先给这些 buyer 钱包充值少量 OKB (约 0.001-0.002 OKB/钱包) 用于支付 gas 费用');
+                    throw new Error(`${insufficientBuyers.length}/${buyerSenders.length} 个 Buyer 钱包 OKB 余额不足！` +
+                        `ERC-4337 限制：所有 UserOps 在 Validation 阶段就需要支付 prefund（gas 费用），此时卖出和分发还没执行。` +
+                        `请先给 buyer 钱包充值少量 OKB (约 0.001-0.002 OKB/钱包)。`);
+                }
+                console.log('[AA Portal 直接分发] ✅ Buyer 钱包 prefund 检查通过，所有钱包余额充足');
                 // ✅ 直接分发模式：
                 // - 原生代币模式：分发金额 = 买入金额 + 买方 prefund
                 // - ERC20 模式：只分发 ERC20 代币，prefund 需要 buyer 自己有 OKB
@@ -793,14 +823,21 @@ export class AAPortalSwapExecutor {
                 const buySwapData = encodeBuyCallWithQuote(tokenAddress, quoteToken, buyWei, 0n);
                 buyCallData = encodeExecuteBatch([quoteToken, FLAP_PORTAL], [0n, 0n], [approveData, buySwapData]);
             }
-            const signedBuy = await this.aaManager.buildUserOpWithState({
+            // ✅ 关键修复：使用 buildUserOpWithFixedGas，确保 callGasLimit 与预检查时一致
+            // 预检查使用 PORTAL_BUY_CALL_GAS_LIMIT (400,000)，这里也必须使用相同的值
+            // 否则 buildUserOpWithState 会动态估算，可能得到更高的值，导致 prefund 不足
+            const { userOp: buyUserOp } = await this.aaManager.buildUserOpWithFixedGas({
                 ownerWallet: buyerOwners[i],
                 sender: ai.sender,
                 nonce: nonceMap.next(ai.sender),
                 initCode: consumeInitCode(ai.sender),
                 callData: buyCallData,
-                signOnly: true,
+                deployed: ai.deployed,
+                fixedGas: {
+                    callGasLimit: PORTAL_BUY_CALL_GAS_LIMIT,
+                },
             });
+            const signedBuy = await this.aaManager.signUserOp(buyUserOp, buyerOwners[i]);
             outOps.push(signedBuy.userOp);
         }
         const signedHandleOps = await this.bundleExecutor['signHandleOpsTx']({

package/package.json

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