four-flap-meme-sdk 1.5.98 → 1.5.99

package/dist/xlayer/bundle.js

@@ -808,6 +808,7 @@ export class BundleExecutor {
                     if (dexType === 'V3') {
                         routerAddress = POTATOSWAP_V3_ROUTER;
                         const v3Fee = lpFeeProfileToV3Fee(tokenState.lpFeeProfile);
+                        // ✅ V3 卖出需要 unwrap WOKB 到 OKB
                         swapData = encodeSwapExactTokensForETHV3({
                             tokenIn: tokenAddress,
                             tokenOut: WOKB,
@@ -816,7 +817,8 @@ export class BundleExecutor {
                             deadline,
                             amountIn: it.sellAmount,
                             amountOutMinimum: 0n,
-                            sqrtPriceLimitX96: 0n
+                            sqrtPriceLimitX96: 0n,
+                            unwrapRecipient: it.sender, // ✅ 添加 unwrap 接收者
                         });
                     }
                     else {

package/dist/xlayer/constants.d.ts

@@ -74,6 +74,6 @@ export declare const PORTAL_ABI: readonly ["function swapExactInput((address inp
 export declare const ERC20_ABI: readonly ["function balanceOf(address account) view returns (uint256)", "function allowance(address owner, address spender) view returns (uint256)", "function approve(address spender, uint256 amount) returns (bool)", "function transfer(address to, uint256 amount) returns (bool)", "function decimals() view returns (uint8)", "function symbol() view returns (string)", "function name() view returns (string)"];
 /** PotatoSwap V2 Router ABI */
 export declare const POTATOSWAP_V2_ROUTER_ABI: readonly ["function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)", "function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)", "function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)", "function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable", "function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external", "function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external", "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)", "function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts)", "function WETH() external pure returns (address)"];
-/** PotatoSwap V3 Router ABI (SwapRouter02) */
-export declare const POTATOSWAP_V3_ROUTER_ABI: readonly ["function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)", "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)"];
+/** PotatoSwap V3 Router ABI (SwapRouter - Legacy 版本，deadline 在 struct 内部) */
+export declare const POTATOSWAP_V3_ROUTER_ABI: readonly ["function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)", "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)", "function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)", "function unwrapWETH9(uint256 amountMinimum, address recipient) external payable", "function refundETH() external payable"];
 export type HexString = `0x${string}`;

package/dist/xlayer/constants.js

@@ -146,8 +146,15 @@ export const POTATOSWAP_V2_ROUTER_ABI = [
     'function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts)',
     'function WETH() external pure returns (address)',
 ];
-/** PotatoSwap V3 Router ABI (SwapRouter02) */
+/** PotatoSwap V3 Router ABI (SwapRouter - Legacy 版本，deadline 在 struct 内部) */
 export const POTATOSWAP_V3_ROUTER_ABI = [
+    // exactInputSingle - 单跳交换，deadline 在 params 内部（Legacy 版本）
     'function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountOut)',
     'function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)',
+    // multicall - 打包多个调用（Legacy 版本不含 deadline 参数）
+    'function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)',
+    // unwrapWETH9 - 将 WOKB 转换为 OKB（用于卖出后获取原生币）
+    'function unwrapWETH9(uint256 amountMinimum, address recipient) external payable',
+    // refundETH - 退还多余的 ETH（用于买入时的找零）
+    'function refundETH() external payable',
 ];

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

@@ -3,7 +3,7 @@
  */
 import { Wallet, ethers } from 'ethers';
 import { AANonceMap, } from './types.js';
-import { POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, WOKB, MULTICALL3, } from './constants.js';
+import { POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, POTATOSWAP_V3_FACTORY, WOKB, MULTICALL3, } from './constants.js';
 import { AAAccountManager, encodeExecute } from './aa-account.js';
 import { encodeApproveCall, lpFeeProfileToV3Fee, } from './portal-ops.js';
 import { DexQuery, encodeSwapExactETHForTokensSupportingFee, encodeSwapExactTokensForETHSupportingFee, encodeSwapExactETHForTokensV3, encodeSwapExactTokensForETHV3, } from './dex.js';
@@ -12,6 +12,64 @@ import { PROFIT_CONFIG } from '../utils/constants.js';
 const multicallIface = new ethers.Interface([
     'function aggregate3Value((address target,bool allowFailure,uint256 value,bytes callData)[] calls) payable returns ((bool success,bytes returnData)[] returnData)',
 ]);
+// ============================================================================
+// V3 Slot0 报价（用于 XLayer 没有 V3 Quoter 的情况）
+// ============================================================================
+const V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)',
+];
+const V3_POOL_ABI = [
+    'function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16 observationIndex,uint16 observationCardinality,uint16 observationCardinalityNext,uint8 feeProtocol,bool unlocked)',
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+];
+const V3_FEE_DENOMINATOR = 1000000n;
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * 使用 V3 Pool 的 slot0 获取 Token → WOKB 的报价
+ * 这是一个现货价计算，比 V3 Quoter 更简单但精度稍低
+ */
+async function quoteV3ViaSlot0(params) {
+    try {
+        const { provider, tokenIn, amountIn, fee } = params;
+        if (!tokenIn || amountIn <= 0n)
+            return 0n;
+        const tokenInLower = tokenIn.toLowerCase();
+        const wokbLower = WOKB.toLowerCase();
+        if (tokenInLower === wokbLower)
+            return amountIn;
+        const factory = new ethers.Contract(POTATOSWAP_V3_FACTORY, V3_FACTORY_ABI, provider);
+        const poolAddr = await factory.getPool(tokenIn, WOKB, fee);
+        if (!poolAddr || poolAddr.toLowerCase() === ZERO_ADDRESS.toLowerCase())
+            return 0n;
+        const pool = new ethers.Contract(poolAddr, V3_POOL_ABI, provider);
+        const [t0, t1, slot0] = await Promise.all([pool.token0(), pool.token1(), pool.slot0()]);
+        if (!t0 || !t1 || !slot0)
+            return 0n;
+        const sqrtPriceX96 = BigInt(slot0[0]);
+        if (sqrtPriceX96 <= 0n)
+            return 0n;
+        // 扣除手续费
+        const amountInLessFee = (amountIn * (V3_FEE_DENOMINATOR - BigInt(fee))) / V3_FEE_DENOMINATOR;
+        if (amountInLessFee <= 0n)
+            return 0n;
+        const Q192 = 2n ** 192n;
+        const num = sqrtPriceX96 * sqrtPriceX96;
+        const t0Lower = String(t0).toLowerCase();
+        const t1Lower = String(t1).toLowerCase();
+        // sqrtPriceX96 表示 token1/token0 的现货价
+        if (tokenInLower === t0Lower && wokbLower === t1Lower) {
+            return (amountInLessFee * num) / Q192;
+        }
+        if (tokenInLower === t1Lower && wokbLower === t0Lower) {
+            return (amountInLessFee * Q192) / num;
+        }
+        return 0n;
+    }
+    catch {
+        return 0n;
+    }
+}
 function chunkArray(arr, size) {
     const out = [];
     const n = Math.max(1, Math.floor(size));
@@ -140,15 +198,37 @@ export class AADexSwapExecutor {
             needApprove = allowance < sellAmountWei;
         }
         // 估算卖出输出（用于利润提取与 buy 预算）
+        // ✅ V3 模式：V2 报价可能失败，需要使用 slot0 报价
         const quotedSellOutWei = await (async () => {
+            // 如果是 V3 模式，优先使用 slot0 报价
+            if (isV3Trade) {
+                const v3Fee = lpFeeProfileToV3Fee(lpFeeProfile);
+                const slot0Quote = await quoteV3ViaSlot0({
+                    provider,
+                    tokenIn: tokenAddress,
+                    amountIn: sellAmountWei,
+                    fee: v3Fee,
+                });
+                if (slot0Quote > 0n) {
+                    console.log(`[AA V3 捆绑换手] slot0 报价成功: ${ethers.formatEther(slot0Quote)} OKB`);
+                    return slot0Quote;
+                }
+                // slot0 报价失败，尝试 V2 fallback
+            }
             try {
+                // V2 报价（大多数代币同时有 V2/V3 池子）
                 return await this.dexQuery.quoteTokenToOkb(sellAmountWei, tokenAddress);
             }
             catch {
+                // V2 报价失败时返回 0
                 return 0n;
             }
         })();
         // buyAmount：若未传则按 quotedSellOut 计算；利润从 quotedSellOut 中刮取，但要保证买入资金充足
+        // ✅ 修复：如果报价失败且未传入 buyAmountOkb，抛出明确错误
+        if (!buyAmountOkb && quotedSellOutWei === 0n) {
+            throw new Error('AA 捆绑换手：无法获取报价（V3 池子不存在或流动性不足），请明确传入 buyAmountOkb 参数');
+        }
         const requestedBuyWei = buyAmountOkb
             ? ethers.parseEther(String(buyAmountOkb))
             : (quotedSellOutWei * BigInt(10000 - slippageBps)) / 10000n;
@@ -177,16 +257,18 @@ export class AADexSwapExecutor {
         const deadline = this.getDexDeadline();
         let sellSwapData;
         if (isV3Trade) {
-            // V3: 使用 exactInputSingle
+            // V3: 使用 multicall(exactInputSingle + unwrapWETH9)
+            // 注意：V3 卖出得到的是 WOKB，需要 unwrap 成 OKB
             sellSwapData = encodeSwapExactTokensForETHV3({
                 tokenIn: tokenAddress,
                 tokenOut: WOKB,
                 fee: lpFeeProfileToV3Fee(lpFeeProfile),
-                recipient: sellerSender,
+                recipient: sellerSender, // 会被函数内部替换为 ADDRESS_THIS
                 deadline,
                 amountIn: sellAmountWei,
                 amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
+                unwrapRecipient: sellerSender, // ✅ unwrap 后发送到 sellerSender
             });
         }
         else {
@@ -368,16 +450,18 @@ export class AADexSwapExecutor {
         const deadline = this.getDexDeadline();
         let sellSwapData;
         if (isV3Trade) {
-            // V3: 使用 exactInputSingle
+            // V3: 使用 multicall(exactInputSingle + unwrapWETH9)
+            // 注意：V3 卖出得到的是 WOKB，需要 unwrap 成 OKB
             sellSwapData = encodeSwapExactTokensForETHV3({
                 tokenIn: tokenAddress,
                 tokenOut: WOKB,
                 fee: lpFeeProfileToV3Fee(lpFeeProfile),
-                recipient: sellerAi.sender,
+                recipient: sellerAi.sender, // 会被函数内部替换为 ADDRESS_THIS
                 deadline,
                 amountIn: sellAmountWei,
                 amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
+                unwrapRecipient: sellerAi.sender, // ✅ unwrap 后发送到 sellerAi.sender
             });
         }
         else {
@@ -398,7 +482,22 @@ export class AADexSwapExecutor {
         const buyAmountsWei = buyAmountsOkb.map(a => ethers.parseEther(a));
         const totalBuyWei = buyAmountsWei.reduce((a, b) => a + (b ?? 0n), 0n);
         // Profit op：估算卖出输出，按比例刮取（但必须保证分发/买入资金充足）
+        // ✅ V3 模式：优先使用 slot0 报价
         const quotedSellOutWei = await (async () => {
+            // 如果是 V3 模式，优先使用 slot0 报价
+            if (isV3Trade) {
+                const v3Fee = lpFeeProfileToV3Fee(lpFeeProfile);
+                const slot0Quote = await quoteV3ViaSlot0({
+                    provider,
+                    tokenIn: tokenAddress,
+                    amountIn: sellAmountWei,
+                    fee: v3Fee,
+                });
+                if (slot0Quote > 0n) {
+                    console.log(`[AA V3 批量换手] slot0 报价成功: ${ethers.formatEther(slot0Quote)} OKB`);
+                    return slot0Quote;
+                }
+            }
             try {
                 return await this.dexQuery.quoteTokenToOkb(sellAmountWei, tokenAddress);
             }

package/dist/xlayer/dex-bundle.js

@@ -306,6 +306,7 @@ export class DexBundleExecutor {
             const sellNonce = nonceMap.next(sender);
             let sellSwapData;
             if (isV3) {
+                // ✅ V3 卖出需要 unwrap WOKB 到 OKB
                 sellSwapData = encodeSwapExactTokensForETHV3({
                     tokenIn: tokenAddress,
                     tokenOut: WOKB,
@@ -315,6 +316,7 @@ export class DexBundleExecutor {
                     amountIn: sellAmount,
                     amountOutMinimum: 0n,
                     sqrtPriceLimitX96: 0n,
+                    unwrapRecipient: sender, // ✅ 添加 unwrap 接收者
                 });
             }
             else {

package/dist/xlayer/dex.d.ts

@@ -7,21 +7,10 @@
  * - 通过 AA 账户执行
  */
 import type { XLayerConfig, DexSwapResult } from './types.js';
-export declare function encodeSwapExactETHForTokensV3(params: {
-    tokenIn: string;
-    tokenOut: string;
-    fee: number;
-    recipient: string;
-    deadline: number;
-    amountIn: bigint;
-    amountOutMinimum: bigint;
-    sqrtPriceLimitX96: bigint;
-}): string;
 /**
- * 编码 swapExactTokensForETHV3 调用
- * 对齐 Uniswap V3 的 exactInputSingle 逻辑
+ * V3 exactInputSingle 参数结构（Legacy 版本，包含 deadline）
  */
-export declare function encodeSwapExactTokensForETHV3(params: {
+interface V3ExactInputSingleParams {
     tokenIn: string;
     tokenOut: string;
     fee: number;
@@ -30,6 +19,37 @@ export declare function encodeSwapExactTokensForETHV3(params: {
     amountIn: bigint;
     amountOutMinimum: bigint;
     sqrtPriceLimitX96: bigint;
+}
+/**
+ * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
+ */
+export declare function encodeUnwrapWETH9(amountMinimum: bigint, recipient: string): string;
+/**
+ * 编码 refundETH 调用（退还多余的 ETH）
+ */
+export declare function encodeRefundETH(): string;
+/**
+ * 编码 V3 multicall 调用（Legacy 版本，不含 deadline）
+ */
+export declare function encodeV3Multicall(data: string[]): string;
+/**
+ * ✅ 编码 V3 买入调用（OKB → Token）
+ *
+ * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
+ * - AA 的 execute 会正确传递 msg.value
+ * - V3 Router 会自动将原生币包装为 WOKB
+ *
+ * 对于 EOA 模式：调用者需要自己用 multicall 包装
+ */
+export declare function encodeSwapExactETHForTokensV3(params: V3ExactInputSingleParams): string;
+/**
+ * ✅ 编码 V3 卖出调用（Token → OKB）
+ * 使用 multicall 包装 exactInputSingle + unwrapWETH9
+ *
+ * 注意：V3 卖出返回的是 WOKB（ERC20），需要调用 unwrapWETH9 转换为 OKB
+ */
+export declare function encodeSwapExactTokensForETHV3(params: V3ExactInputSingleParams & {
+    unwrapRecipient?: string;
 }): string;
 /**
  * 编码 swapExactETHForTokens 调用
@@ -190,3 +210,4 @@ export declare function quoteOkbToToken(okbAmount: bigint, tokenAddress: string,
  * 快速获取 Token -> OKB 报价
  */
 export declare function quoteTokenToOkb(tokenAmount: bigint, tokenAddress: string, config?: DexConfig): Promise<bigint>;
+export {};

package/dist/xlayer/dex.js

@@ -15,15 +15,62 @@ import { encodeApproveCall, parseOkb, formatOkb } from './portal-ops.js';
 // ============================================================================
 const routerIface = new Interface(POTATOSWAP_V2_ROUTER_ABI);
 const v3RouterIface = new Interface(POTATOSWAP_V3_ROUTER_ABI);
-export function encodeSwapExactETHForTokensV3(params) {
+/**
+ * 编码 exactInputSingle 调用（内部使用）
+ */
+function encodeExactInputSingle(params) {
     return v3RouterIface.encodeFunctionData('exactInputSingle', [params]);
 }
 /**
- * 编码 swapExactTokensForETHV3 调用
- * 对齐 Uniswap V3 的 exactInputSingle 逻辑
+ * 编码 unwrapWETH9 调用（将 WOKB 转换为 OKB）
+ */
+export function encodeUnwrapWETH9(amountMinimum, recipient) {
+    return v3RouterIface.encodeFunctionData('unwrapWETH9', [amountMinimum, recipient]);
+}
+/**
+ * 编码 refundETH 调用（退还多余的 ETH）
+ */
+export function encodeRefundETH() {
+    return v3RouterIface.encodeFunctionData('refundETH', []);
+}
+/**
+ * 编码 V3 multicall 调用（Legacy 版本，不含 deadline）
+ */
+export function encodeV3Multicall(data) {
+    return v3RouterIface.encodeFunctionData('multicall', [data]);
+}
+/**
+ * ✅ 编码 V3 买入调用（OKB → Token）
+ *
+ * 对于 AA 模式：直接返回 exactInputSingle 编码（不需要 multicall 包装）
+ * - AA 的 execute 会正确传递 msg.value
+ * - V3 Router 会自动将原生币包装为 WOKB
+ *
+ * 对于 EOA 模式：调用者需要自己用 multicall 包装
+ */
+export function encodeSwapExactETHForTokensV3(params) {
+    // 直接返回 exactInputSingle 编码
+    // V3 Router 会自动处理原生币 → WOKB 的转换
+    return encodeExactInputSingle(params);
+}
+/**
+ * ✅ 编码 V3 卖出调用（Token → OKB）
+ * 使用 multicall 包装 exactInputSingle + unwrapWETH9
+ *
+ * 注意：V3 卖出返回的是 WOKB（ERC20），需要调用 unwrapWETH9 转换为 OKB
  */
 export function encodeSwapExactTokensForETHV3(params) {
-    return v3RouterIface.encodeFunctionData('exactInputSingle', [params]);
+    // V3 卖出需要：1) 先 swap 到 Router 地址；2) 再 unwrap 到最终接收者
+    const ADDRESS_THIS = '0x0000000000000000000000000000000000000002'; // V3 Router 的 ADDRESS_THIS
+    const swapParams = {
+        ...params,
+        recipient: ADDRESS_THIS, // 先发送到 Router 内部
+    };
+    const swapData = encodeExactInputSingle(swapParams);
+    // unwrap 到最终接收者
+    const finalRecipient = params.unwrapRecipient || params.recipient;
+    const unwrapData = encodeUnwrapWETH9(0n, finalRecipient); // amountMinimum = 0，不做最小值检查
+    return encodeV3Multicall([swapData, unwrapData]);
 }
 /**
  * 编码 swapExactETHForTokens 调用

package/package.json

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