four-flap-meme-sdk 1.3.49 → 1.3.50

package/dist/dex/direct-router.js

@@ -82,14 +82,14 @@ const V2_ROUTER_ABI = [
 /**
  * SwapRouter02 的 V2 方法 ABI (PotatoSwap)
  *
- * 重要：根据实际 ABI，SwapRouter02 的 V2 方法只有：
+ * 重要：SwapRouter02 的 V2 方法只有：
  * - swapExactTokensForTokens(amountIn, amountOutMin, path[], to)
  * - swapTokensForExactTokens(amountOut, amountInMax, path[], to)
  *
  * 没有 swapExactETHForTokens / swapExactTokensForETH！
- * 必须手动处理 ETH/WETH 转换：
- * - 买入(ETH→Token): wrapETH + swapExactTokensForTokens，通过 multicall 组合
- * - 卖出(Token→ETH): swapExactTokensForTokens(to=ADDRESS_THIS) + unwrapWETH9，通过 multicall 组合
+ * 需要手动处理 ETH/WETH 转换：
+ * - 买入(ETH->Token): wrapETH + swapExactTokensForTokens
+ * - 卖出(Token->ETH): swapExactTokensForTokens(to=ADDRESS_THIS) + unwrapWETH9
  */
 const SWAP_ROUTER02_V2_ABI = [
     // V2 交换方法（只有 token-to-token）
@@ -97,15 +97,15 @@ const SWAP_ROUTER02_V2_ABI = [
     'function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to) external payable returns (uint256 amountIn)',
     // Multicall - 多种重载
     'function multicall(uint256 deadline, bytes[] calldata data) external payable returns (bytes[] memory results)',
-    'function multicall(bytes32 previousBlockhash, bytes[] calldata data) external payable returns (bytes[] memory results)',
     'function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)',
     // 辅助方法 - ETH/WETH 转换
     'function wrapETH(uint256 value) external payable',
     'function unwrapWETH9(uint256 amountMinimum, address recipient) external payable',
     'function unwrapWETH9(uint256 amountMinimum) external payable',
     'function refundETH() external payable',
-    // 代币操作
+    // pull 方法 - 从用户拉取代币到 Router
     'function pull(address token, uint256 value) external payable',
+    // sweepToken - 将 Router 中的代币发送给用户
     'function sweepToken(address token, uint256 amountMinimum, address recipient) external payable',
     'function sweepToken(address token, uint256 amountMinimum) external payable',
 ];
@@ -269,24 +269,20 @@ async function buildProfitTransaction(wallet, profitAmountWei, nonce, gasPrice,
 // V2 直接交易
 // ============================================================================
 /**
- * 判断是否是 SwapRouter02 (仅 XLayer PotatoSwap)
- *
- * 只有 XLayer PotatoSwap 使用 SwapRouter02 进行 V2 交易
- * BSC/Monad 的 V2 交易使用传统的 V2 Router（带 deadline 参数）
- *
- * SwapRouter02 的 V2 方法签名不同：
- * - swapExactETHForTokens(amountOutMin, path[], to) - 没有 deadline
- * - swapExactTokensForETH(amountIn, amountOutMin, path[], to) - 没有 deadline
+ * 判断是否是 SwapRouter02 (PotatoSwap, PancakeSwap V3 等)
+ * SwapRouter02 的 V2 方法签名不同，需要特殊处理
  */
 function isSwapRouter02(chain, routerAddress) {
     const chainUpper = chain.toUpperCase();
     const addrLower = routerAddress.toLowerCase();
-    // ✅ 只有 XLayer PotatoSwap SwapRouter02 走这个逻辑
+    // XLayer PotatoSwap SwapRouter02
     if (chainUpper === 'XLAYER' && addrLower === DIRECT_ROUTERS.XLAYER.POTATOSWAP_V2.toLowerCase()) {
         return true;
     }
-    // ❌ BSC V2 交易使用传统 PancakeSwap V2 Router，不走 SwapRouter02 逻辑
-    // ❌ Monad V2 交易使用传统 V2 Router，不走 SwapRouter02 逻辑
+    // BSC PancakeSwap V3 SwapRouter02
+    if (chainUpper === 'BSC' && addrLower === DIRECT_ROUTERS.BSC.PANCAKESWAP_V3.toLowerCase()) {
+        return true;
+    }
     return false;
 }
 /**
@@ -330,39 +326,42 @@ export async function directV2BatchBuy(params) {
         let txData;
         let txValue;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
-            // ABI 中没有 swapExactETHForTokens，只有 swapExactTokensForTokens
+            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH wrap
+            // 文档：没有 swapExactETHForTokens / swapExactTokensForETH
+            const multicallData = [];
             if (useNative) {
-                // ETH -> 代币：直接用 swapExactTokensForTokens（参考之前成功的交易）
-                // 之前成功的交易只用了一个 swapExactTokensForTokens，没有 wrapETH
-                // SwapRouter02 会自动处理 msg.value 的 ETH
+                // ETH -> 代币：
+                // 1. wrapETH(msg.value) - 将 ETH 转为 WETH
+                // 2. swapExactTokensForTokens(WETH -> Token)
+                const wrapData = routerIface.encodeFunctionData('wrapETH', [amountWei]);
+                multicallData.push(wrapData);
                 const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
                     amountWei,
                     0n, // amountOutMin
                     path, // path: [WETH, ..., tokenOut]
                     wallet.address, // to
                 ]);
-                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
-                txValue = amountWei;
+                multicallData.push(swapData);
+                // refundETH - 退回多余的 ETH（如果有）
+                const refundData = routerIface.encodeFunctionData('refundETH', []);
+                multicallData.push(refundData);
             }
             else {
-                // 代币 -> 代币：也用 multicall 包装
+                // 代币 -> 代币：直接 swapExactTokensForTokens
                 const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
                     amountWei,
                     0n, // amountOutMin
                     path,
                     wallet.address, // to
                 ]);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
-                txValue = 0n;
+                multicallData.push(swapData);
             }
+            // 使用 multicall 包装，传递 deadline
+            txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
+                deadline,
+                multicallData,
+            ]);
+            txValue = useNative ? amountWei : 0n;
         }
         else if (useNative) {
             // 传统 V2 Router: 原生币 → Token
@@ -489,49 +488,46 @@ export async function directV2BatchSell(params) {
         // 卖出交易
         let txData;
         if (useSwapRouter02) {
-            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
-            // ABI 中没有 swapExactTokensForETH，只有 swapExactTokensForTokens
+            // ✅ SwapRouter02: 只有 swapExactTokensForTokens，需要手动处理 ETH unwrap
+            const router02Iface = new ethers.Interface(SWAP_ROUTER02_V2_ABI);
+            const multicallData = [];
+            // SwapRouter02 特殊地址约定：
+            // address(1) = ADDRESS_THIS = Router 合约自己
+            // address(2) = MSG_SENDER = 调用者
+            const ADDRESS_THIS = '0x0000000000000000000000000000000000000001'; // Router 自己
             if (useNativeOutput) {
-                // 代币 -> ETH：swapExactTokensForTokens + unwrapWETH9
-                // 
-                // 根据合约源码 Constants.sol:
-                // address(1) = MSG_SENDER = 调用者（用户）
-                // address(2) = ADDRESS_THIS = Router 合约自己
-                const ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
-                const multicallData = [];
-                // 1. swapExactTokensForTokens - Token -> WETH，发送到 Router 自己
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
+                // 代币 -> ETH：
+                // 1. swapExactTokensForTokens(token -> WETH, to = ADDRESS_THIS)
+                // 2. unwrapWETH9(WETH -> ETH, to = 用户)
+                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
                     sellAmount,
                     0n, // amountOutMin
                     path, // path: [token, ..., WETH]
-                    ADDRESS_THIS, // to = address(2) = Router 自己，WETH 留在 Router 中
+                    ADDRESS_THIS, // to = Router 自己，WETH 留在 Router 中
                 ]);
                 multicallData.push(swapData);
-                // 2. unwrapWETH9 - 将 Router 中的 WETH 解包为 ETH 发送给用户
-                const unwrapData = routerIface.encodeFunctionData('unwrapWETH9(uint256,address)', [
+                // unwrap WETH -> ETH 发送给用户
+                const unwrapData = router02Iface.encodeFunctionData('unwrapWETH9(uint256,address)', [
                     0n, // amountMinimum
                     wallet.address, // recipient = 用户
                 ]);
                 multicallData.push(unwrapData);
-                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    multicallData,
-                ]);
             }
             else {
-                // 代币 -> 代币：也用 multicall 包装
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
+                // 代币 -> 代币：直接 swapExactTokensForTokens
+                const swapData = router02Iface.encodeFunctionData('swapExactTokensForTokens', [
                     sellAmount,
                     0n, // amountOutMin
                     path,
                     wallet.address, // to
                 ]);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
+                multicallData.push(swapData);
             }
+            // 使用 multicall 包装，传递 deadline
+            txData = router02Iface.encodeFunctionData('multicall(uint256,bytes[])', [
+                deadline,
+                multicallData,
+            ]);
         }
         else if (useNativeOutput) {
             txData = routerIface.encodeFunctionData('swapExactTokensForETHSupportingFeeOnTransferTokens', [

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

@@ -0,0 +1,16 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
+/**
+ * 验证公钥格式（Base64）
+ */
+export declare function validatePublicKey(publicKeyBase64: string): boolean;

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

@@ -0,0 +1,146 @@
+/**
+ * ECDH + AES-GCM 加密工具（浏览器兼容）
+ * 用于将签名交易用服务器公钥加密
+ */
+/**
+ * 获取全局 crypto 对象（最简单直接的方式）
+ */
+function getCryptoAPI() {
+    // 尝试所有可能的全局对象，优先浏览器环境
+    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
+        (typeof self !== 'undefined' && self.crypto) ||
+        (typeof global !== 'undefined' && global.crypto) ||
+        (typeof globalThis !== 'undefined' && globalThis.crypto);
+    if (!cryptoObj) {
+        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
+            '请确保在 HTTPS 或 localhost 下运行');
+    }
+    return cryptoObj;
+}
+/**
+ * 获取 SubtleCrypto（用于加密操作）
+ */
+function getSubtleCrypto() {
+    const crypto = getCryptoAPI();
+    if (!crypto.subtle) {
+        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
+        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
+        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
+            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
+            '3) 不在无痕/隐私浏览模式下');
+    }
+    return crypto.subtle;
+}
+/**
+ * Base64 转 ArrayBuffer（优先使用浏览器 API）
+ */
+function base64ToArrayBuffer(base64) {
+    // 浏览器环境（优先）
+    if (typeof atob !== 'undefined') {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(base64, 'base64').buffer;
+    }
+    throw new Error('❌ Base64 解码不可用');
+}
+/**
+ * ArrayBuffer 转 Base64（优先使用浏览器 API）
+ */
+function arrayBufferToBase64(buffer) {
+    // 浏览器环境（优先）
+    if (typeof btoa !== 'undefined') {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    // Node.js 环境（fallback）
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(buffer).toString('base64');
+    }
+    throw new Error('❌ Base64 编码不可用');
+}
+/**
+ * 生成随机 Hex 字符串
+ */
+function randomHex(length) {
+    const crypto = getCryptoAPI();
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * 用服务器公钥加密签名交易（ECDH + AES-GCM）
+ *
+ * @param signedTransactions 签名后的交易数组
+ * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
+ * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
+ */
+export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
+    try {
+        // 0. 获取 SubtleCrypto 和 Crypto API
+        const subtle = getSubtleCrypto();
+        const crypto = getCryptoAPI();
+        // 1. 准备数据
+        const payload = {
+            signedTransactions,
+            timestamp: Date.now(),
+            nonce: randomHex(8)
+        };
+        const plaintext = JSON.stringify(payload);
+        // 2. 生成临时 ECDH 密钥对
+        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
+        // 3. 导入服务器公钥
+        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
+        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+        // 4. 派生共享密钥（AES-256）
+        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
+        // 5. AES-GCM 加密
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
+        // 6. 导出临时公钥
+        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
+        // 7. 返回加密包（JSON 格式）
+        return JSON.stringify({
+            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
+            i: arrayBufferToBase64(iv.buffer), // IV
+            d: arrayBufferToBase64(encrypted) // 密文
+        });
+    }
+    catch (error) {
+        throw new Error(`加密失败: ${error?.message || String(error)}`);
+    }
+}
+/**
+ * 验证公钥格式（Base64）
+ */
+export function validatePublicKey(publicKeyBase64) {
+    try {
+        if (!publicKeyBase64)
+            return false;
+        // Base64 字符集验证
+        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
+            return false;
+        // ECDH P-256 公钥固定长度 65 字节（未压缩）
+        // Base64 编码后约 88 字符
+        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/lp-inspect.d.ts

@@ -29,6 +29,8 @@ export interface PoolPairInfo {
     reserveToken: string;
     reserveQuote: string;
     reserveQuoteRaw?: bigint;
+    reserveTokenRaw?: bigint;
+    poolRatio?: string;
 }
 /** V3 池子信息（带 fee） */
 export interface V3PoolInfo extends PoolPairInfo {
@@ -53,6 +55,9 @@ export interface BestPoolInfo {
     pairAddress: string;
     liquidity: string;
     liquidityRaw: bigint;
+    reserveToken?: string;
+    reserveTokenRaw?: bigint;
+    poolRatio?: string;
 }
 /** LP 平台类型 */
 export type LPPlatform = 'FOUR' | 'FLAP' | 'PANCAKESWAP_V2' | 'PANCAKESWAP_V3' | 'UNISWAP_V2' | 'UNISWAP_V3' | 'MULTI_DEX' | 'UNKNOWN';
@@ -60,6 +65,8 @@ export type LPPlatform = 'FOUR' | 'FLAP' | 'PANCAKESWAP_V2' | 'PANCAKESWAP_V3' |
 export interface LPInfo {
     platform: LPPlatform;
     decimals?: number;
+    totalSupply?: string;
+    totalSupplyRaw?: bigint;
     four?: {
         helper: string;
         reserveNative?: string;

package/dist/utils/lp-inspect.js

@@ -222,11 +222,25 @@ export async function inspectTokenLP(token, opts) {
     if (opts.customDexConfig) {
         chainConfig = { ...chainConfig, ...opts.customDexConfig };
     }
-    // 查询代币精度
+    // 查询代币精度和总供应量
     let tokenDecimals;
+    let totalSupplyRaw;
     try {
-        tokenDecimals = await getTokenDecimals(token, provider);
+        const tokenContract = new Contract(token, [
+            'function decimals() view returns (uint8)',
+            'function totalSupply() view returns (uint256)'
+        ], provider);
+        const [decimals, supply] = await Promise.all([
+            tokenContract.decimals().catch(() => 18),
+            tokenContract.totalSupply().catch(() => undefined)
+        ]);
+        tokenDecimals = Number(decimals);
+        totalSupplyRaw = supply ? BigInt(supply) : undefined;
         result.decimals = tokenDecimals;
+        if (totalSupplyRaw !== undefined) {
+            result.totalSupplyRaw = totalSupplyRaw;
+            result.totalSupply = formatBalance(totalSupplyRaw, shouldFormat, tokenDecimals);
+        }
     }
     catch {
         tokenDecimals = 18;
@@ -328,6 +342,8 @@ export async function inspectTokenLP(token, opts) {
                             pairAddress: pair.pairAddress,
                             liquidity: pair.reserveQuote,
                             liquidityRaw: normalizeLiquidity(pair.reserveQuoteRaw, pair.quoteDecimals),
+                            reserveToken: pair.reserveToken, // ✅ 新增
+                            reserveTokenRaw: pair.reserveTokenRaw, // ✅ 新增
                         });
                     }
                 }
@@ -356,6 +372,8 @@ export async function inspectTokenLP(token, opts) {
                             pairAddress: pool.pairAddress,
                             liquidity: pool.reserveQuote,
                             liquidityRaw: normalizeLiquidity(pool.reserveQuoteRaw, pool.quoteDecimals),
+                            reserveToken: pool.reserveToken, // ✅ 新增
+                            reserveTokenRaw: pool.reserveTokenRaw, // ✅ 新增
                         });
                     }
                 }
@@ -371,7 +389,7 @@ export async function inspectTokenLP(token, opts) {
     const dexResults = await Promise.all(dexPromises);
     // 过滤出有流动性的 DEX
     result.allPools = dexResults.filter(dex => dex.v2Pairs.length > 0 || dex.v3Pools.length > 0);
-    // 按流动性排序最佳池子
+    // 按流动性排序最佳池子，并计算 poolRatio
     result.bestPools = allBestPoolCandidates
         .sort((a, b) => {
         // 降序排列
@@ -381,7 +399,37 @@ export async function inspectTokenLP(token, opts) {
             return -1;
         return 0;
     })
-        .slice(0, 10); // 最多返回 10 个
+        .slice(0, 10) // 最多返回 10 个
+        .map(pool => {
+        // ✅ 计算池子代币占比
+        if (pool.reserveTokenRaw && totalSupplyRaw && totalSupplyRaw > 0n) {
+            // 计算百分比：(reserveTokenRaw / totalSupplyRaw) * 100
+            // 为了保持精度，先乘以 10000，再除以 totalSupply，得到万分比
+            const ratioBps = (pool.reserveTokenRaw * 10000n) / totalSupplyRaw;
+            const ratioPercent = Number(ratioBps) / 100; // 转为百分比
+            pool.poolRatio = `${ratioPercent.toFixed(2)}%`;
+        }
+        return pool;
+    });
+    // ✅ 同时为 allPools 中的每个池子计算 poolRatio
+    if (totalSupplyRaw && totalSupplyRaw > 0n) {
+        for (const dexPool of result.allPools) {
+            for (const pair of dexPool.v2Pairs) {
+                if (pair.reserveTokenRaw) {
+                    const ratioBps = (pair.reserveTokenRaw * 10000n) / totalSupplyRaw;
+                    const ratioPercent = Number(ratioBps) / 100;
+                    pair.poolRatio = `${ratioPercent.toFixed(2)}%`;
+                }
+            }
+            for (const pool of dexPool.v3Pools) {
+                if (pool.reserveTokenRaw) {
+                    const ratioBps = (pool.reserveTokenRaw * 10000n) / totalSupplyRaw;
+                    const ratioPercent = Number(ratioBps) / 100;
+                    pool.poolRatio = `${ratioPercent.toFixed(2)}%`;
+                }
+            }
+        }
+    }
     // 确定平台类型
     result.platform = determinePlatform(result.allPools);
     return result;
@@ -450,6 +498,7 @@ async function queryV2Pairs(token, factoryAddress, quoteTokens, provider, multic
                     reserveToken: formatBalance(reserveToken, shouldFormat, tokenDecimals),
                     reserveQuote: formatBalance(reserveQuote, shouldFormat, p.quoteToken.decimals),
                     reserveQuoteRaw: reserveQuote,
+                    reserveTokenRaw: reserveToken, // ✅ 新增
                 });
             }
             catch (err) {
@@ -487,6 +536,7 @@ async function queryV2PairsFallback(token, factoryAddress, quoteTokens, provider
                     reserveToken: formatBalance(reserveToken, shouldFormat, tokenDecimals),
                     reserveQuote: formatBalance(reserveQuote, shouldFormat, qt.decimals),
                     reserveQuoteRaw: reserveQuote,
+                    reserveTokenRaw: reserveToken, // ✅ 新增
                 });
             }
         }
@@ -572,6 +622,7 @@ async function queryV3Pools(token, factoryAddress, quoteTokens, feeTiers, provid
                     reserveToken: formatBalance(tokenBalance, shouldFormat, tokenDecimals),
                     reserveQuote: formatBalance(quoteBalance, shouldFormat, p.quoteToken.decimals),
                     reserveQuoteRaw: quoteBalance,
+                    reserveTokenRaw: tokenBalance, // ✅ 新增
                     fee: p.fee,
                 });
             }
@@ -616,6 +667,7 @@ async function queryV3PoolsFallback(token, factoryAddress, quoteTokens, feeTiers
                         reserveToken: formatBalance(tokenBalance, shouldFormat, tokenDecimals),
                         reserveQuote: formatBalance(quoteBalance, shouldFormat, qt.decimals),
                         reserveQuoteRaw: quoteBalance,
+                        reserveTokenRaw: tokenBalance, // ✅ 新增
                         fee,
                     });
                 }

package/package.json

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