four-flap-meme-sdk 1.3.92 → 1.3.94

package/dist/sol/dex/meteora/dlmm.d.ts

@@ -15,11 +15,22 @@ import type { DlmmPoolInfo, DlmmSwapParams, DlmmAddLiquidityParams, DlmmRemoveLi
 export declare function getDlmmPoolInfo(poolAddress: string, connection?: Connection): Promise<DlmmPoolInfo>;
 /**
  * 通过 Token Mint 查找 DLMM 池
+ * 优化: 使用 Meteora API 替代全量链上查询
  * @param tokenXMint Token X Mint 地址
  * @param tokenYMint Token Y Mint 地址
- * @param connection 可选连接
+ * @param connection 可选连接（备用）
+ */
+export declare function findDlmmPool(tokenXMint: string, tokenYMint: string, _connection?: Connection): Promise<string | null>;
+/**
+ * 通过代币地址获取所有相关的 DLMM 池子
+ * 使用 Meteora API，不再全量查询链上数据
  */
-export declare function findDlmmPool(tokenXMint: string, tokenYMint: string, connection?: Connection): Promise<string | null>;
+export declare function findDlmmPoolsByToken(tokenMint: string): Promise<Array<{
+    address: string;
+    tokenX: string;
+    tokenY: string;
+    binStep: number;
+}>>;
 /**
  * 签名 DLMM Swap 交易
  * @param params Swap 参数

package/dist/sol/dex/meteora/dlmm.js

@@ -7,7 +7,7 @@
 import { PublicKey, Keypair, Transaction, } from '@solana/web3.js';
 import BN from 'bn.js';
 import { StrategyType, ActivationType } from '@meteora-ag/dlmm';
-import { getConnection, getDlmmPool, getAllDlmmPools } from './client.js';
+import { getConnection, getDlmmPool } from './client.js';
 // ============================================================================
 // 池信息查询
 // ============================================================================
@@ -34,27 +34,105 @@ export async function getDlmmPoolInfo(poolAddress, connection) {
 }
 /**
  * 通过 Token Mint 查找 DLMM 池
+ * 优化: 使用 Meteora API 替代全量链上查询
  * @param tokenXMint Token X Mint 地址
  * @param tokenYMint Token Y Mint 地址
- * @param connection 可选连接
+ * @param connection 可选连接（备用）
  */
-export async function findDlmmPool(tokenXMint, tokenYMint, connection) {
+export async function findDlmmPool(tokenXMint, tokenYMint, _connection) {
     try {
-        const lbPairs = await getAllDlmmPools(connection);
-        const matchingPair = lbPairs.find((pair) => {
-            const pairTokenX = pair.account.tokenXMint.toBase58();
-            const pairTokenY = pair.account.tokenYMint.toBase58();
-            return ((pairTokenX === tokenXMint && pairTokenY === tokenYMint) ||
-                (pairTokenX === tokenYMint && pairTokenY === tokenXMint));
-        });
-        if (matchingPair) {
-            return matchingPair.publicKey.toBase58();
+        // 方法1: 使用 Meteora API 查询 (推荐，速度快)
+        const apiResult = await findDlmmPoolByApi(tokenXMint, tokenYMint);
+        if (apiResult) {
+            return apiResult;
         }
+        // 方法2: 如果 API 失败，尝试计算 PDA（某些池子可能有固定 PDA）
+        // 注意：DLMM 池子使用 seeds = [tokenX, tokenY, binStep] 计算 PDA
+        // 但 binStep 不确定，所以这里不做 PDA 计算
+        return null;
     }
     catch (e) {
         console.error('查找 DLMM 池失败:', e);
+        return null;
+    }
+}
+/**
+ * 通过 Meteora API 查找 DLMM 池
+ * API 文档: https://dlmm-api.meteora.ag/swagger-ui/
+ */
+async function findDlmmPoolByApi(tokenXMint, tokenYMint) {
+    try {
+        // 使用 Meteora 官方 API 查询池子
+        const response = await fetch(`https://dlmm-api.meteora.ag/pair/all_by_groups?include_token_mints=${tokenXMint},${tokenYMint}`, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            console.warn('[Meteora API] Request failed:', response.status);
+            return null;
+        }
+        const data = await response.json();
+        // 查找匹配的池子
+        if (data?.groups) {
+            for (const group of data.groups) {
+                if (group.pairs) {
+                    for (const pair of group.pairs) {
+                        const mintX = pair.mint_x;
+                        const mintY = pair.mint_y;
+                        if ((mintX === tokenXMint && mintY === tokenYMint) ||
+                            (mintX === tokenYMint && mintY === tokenXMint)) {
+                            return pair.address;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    catch (e) {
+        console.warn('[Meteora API] 查询失败:', e);
+        return null;
+    }
+}
+/**
+ * 通过代币地址获取所有相关的 DLMM 池子
+ * 使用 Meteora API，不再全量查询链上数据
+ */
+export async function findDlmmPoolsByToken(tokenMint) {
+    try {
+        const response = await fetch(`https://dlmm-api.meteora.ag/pair/all_by_groups?include_token_mints=${tokenMint}`, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return [];
+        }
+        const data = await response.json();
+        const pools = [];
+        if (data?.groups) {
+            for (const group of data.groups) {
+                if (group.pairs) {
+                    for (const pair of group.pairs) {
+                        if (pair.mint_x === tokenMint || pair.mint_y === tokenMint) {
+                            pools.push({
+                                address: pair.address,
+                                tokenX: pair.mint_x,
+                                tokenY: pair.mint_y,
+                                binStep: pair.bin_step || 0,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return pools;
+    }
+    catch (e) {
+        console.warn('[Meteora API] 查询池子列表失败:', e);
+        return [];
     }
-    return null;
 }
 // ============================================================================
 // Swap

package/dist/sol/utils/lp-inspect.js

@@ -41,8 +41,8 @@ async function loadPumpSdk() {
 /** 懒加载 Meteora SDK */
 async function loadMeteoraSdk() {
     const { findDbcPoolByBaseMint, getDbcPoolInfo } = await import('../dex/meteora/dbc.js');
-    const { findDlmmPool, getDlmmPoolInfo } = await import('../dex/meteora/dlmm.js');
-    return { findDbcPoolByBaseMint, getDbcPoolInfo, findDlmmPool, getDlmmPoolInfo };
+    const { findDlmmPool, getDlmmPoolInfo, findDlmmPoolsByToken } = await import('../dex/meteora/dlmm.js');
+    return { findDbcPoolByBaseMint, getDbcPoolInfo, findDlmmPool, getDlmmPoolInfo, findDlmmPoolsByToken };
 }
 /** 懒加载 Orca SDK */
 async function loadOrcaSdk() {
@@ -295,25 +295,38 @@ async function detectPumpSwapPool(mint, connection, debug) {
 }
 /**
  * 检测 Meteora DLMM Pool
+ * 优化: 使用 Meteora API 替代全量链上查询
  */
 async function detectMeteoraDlmm(mint, connection, debug) {
     try {
-        const { findDlmmPool, getDlmmPoolInfo } = await loadMeteoraSdk();
-        // 尝试与 SOL 配对
-        const poolAddress = await findDlmmPool(mint, WSOL, connection);
-        if (!poolAddress)
+        const { findDlmmPoolsByToken, getDlmmPoolInfo } = await loadMeteoraSdk();
+        // 使用 API 查询所有包含该代币的池子
+        const pools = await findDlmmPoolsByToken(mint);
+        if (pools.length === 0) {
+            if (debug)
+                console.log('[LP Inspect] No Meteora DLMM pools found for mint:', mint);
             return null;
-        const poolInfo = await getDlmmPoolInfo(poolAddress, connection);
+        }
+        // 优先选择与 SOL 配对的池子
+        let selectedPool = pools.find(p => p.tokenX === WSOL || p.tokenY === WSOL);
+        if (!selectedPool) {
+            selectedPool = pools[0]; // 如果没有 SOL 池子，选择第一个
+        }
+        if (debug)
+            console.log('[LP Inspect] Found Meteora DLMM pool:', selectedPool.address);
+        // 获取池子详细信息
+        const poolInfo = await getDlmmPoolInfo(selectedPool.address, connection);
         // 判断哪个是 base token
         const isTokenX = poolInfo.tokenXMint === mint;
         const reserveQuote = isTokenX ? poolInfo.tokenYReserve : poolInfo.tokenXReserve;
         const reserveBase = isTokenX ? poolInfo.tokenXReserve : poolInfo.tokenYReserve;
+        const quoteToken = isTokenX ? poolInfo.tokenYMint : poolInfo.tokenXMint;
         return {
             platform: 'METEORA_DLMM',
-            poolAddress,
-            quoteToken: isTokenX ? poolInfo.tokenYMint : poolInfo.tokenXMint,
-            quoteSymbol: 'SOL',
-            quoteDecimals: 9,
+            poolAddress: selectedPool.address,
+            quoteToken,
+            quoteSymbol: quoteToken === WSOL ? 'SOL' : 'UNKNOWN',
+            quoteDecimals: quoteToken === WSOL ? 9 : 6,
             baseToken: mint,
             reserveQuote: reserveQuote || '0',
             reserveQuoteRaw: BigInt(reserveQuote || 0),
@@ -437,26 +450,94 @@ async function detectRaydiumPools(mint, connection, debug) {
                 }
                 // 尝试从链上获取实时数据（支持 CPMM, AMM V4, CLMM）
                 let onChainPrice;
+                let usedOnChainData = false;
                 try {
-                    const onChainData = await fetchRaydiumPoolOnChain(connection, pool.id, programId, debug);
+                    const onChainData = await fetchRaydiumPoolOnChain(connection, pool.id, programId, debug); // 添加类型断言以访问额外属性
                     if (onChainData) {
-                        // 使用链上数据更新储备量
-                        if (isBaseA) {
-                            reserveQuote = onChainData.reserveB;
-                            reserveBase = onChainData.reserveA;
+                        usedOnChainData = true;
+                        // CLMM 需要特殊处理：合约中 token 按地址排序
+                        if (platform === 'RAYDIUM_CLMM' && onChainData.mintA && onChainData.mintB) {
+                            // 合约中：mintA 是地址较小的 token，mintB 是地址较大的 token
+                            // sqrtPriceX64ToPrice 返回 mintB/mintA
+                            // 判断我们查询的代币在合约中的位置
+                            const queryMintIsA = onChainData.mintA === mint;
+                            const queryMintIsB = onChainData.mintB === mint;
+                            if (queryMintIsA) {
+                                // 查询的代币是 mintA（地址较小）
+                                // sqrtPrice 返回 mintB/mintA = quote/base
+                                reserveBase = onChainData.reserveA;
+                                reserveQuote = onChainData.reserveB;
+                                // 我们需要 quote/base 价格，sqrtPrice 已经是这个
+                                onChainPrice = onChainData.price;
+                            }
+                            else if (queryMintIsB) {
+                                // 查询的代币是 mintB（地址较大）
+                                // sqrtPrice 返回 mintB/mintA = base/quote（反了）
+                                reserveBase = onChainData.reserveB;
+                                reserveQuote = onChainData.reserveA;
+                                // 我们需要 quote/base = 1 / (base/quote) = 1 / sqrtPrice
+                                onChainPrice = 1 / onChainData.price;
+                            }
+                            else {
+                                // mint 不在池子中，跳过
+                                if (debug)
+                                    console.log('[LP Inspect] CLMM: mint not found in pool');
+                            }
+                            if (debug) {
+                                console.log('[LP Inspect] CLMM 链上数据:', {
+                                    poolId: pool.id,
+                                    contractMintA: onChainData.mintA,
+                                    contractMintB: onChainData.mintB,
+                                    queryMint: mint,
+                                    queryMintIsA,
+                                    queryMintIsB,
+                                    rawPrice: onChainData.price,
+                                    adjustedPrice: onChainPrice,
+                                    reserveQuote,
+                                    reserveBase,
+                                });
+                            }
                         }
                         else {
-                            reserveQuote = onChainData.reserveA;
-                            reserveBase = onChainData.reserveB;
+                            // CPMM 和 AMM V4：使用原有逻辑
+                            if (isBaseA) {
+                                reserveQuote = onChainData.reserveB;
+                                reserveBase = onChainData.reserveA;
+                            }
+                            else {
+                                reserveQuote = onChainData.reserveA;
+                                reserveBase = onChainData.reserveB;
+                            }
+                            // price 已经是 reserveB/reserveA
+                            onChainPrice = isBaseA ? onChainData.price : (onChainData.price ? 1 / onChainData.price : undefined);
+                        }
+                        if (debug) {
+                            console.log('[LP Inspect] 链上数据 (实时):', {
+                                poolId: pool.id,
+                                platform,
+                                reserveQuote,
+                                reserveBase,
+                                onChainPrice,
+                            });
                         }
-                        onChainPrice = onChainData.price;
-                        if (debug)
-                            console.log('[LP Inspect] Got on-chain data:', { reserveQuote, reserveBase, price: onChainPrice });
                     }
                 }
                 catch (e) {
                     if (debug)
-                        console.log('[LP Inspect] Failed to get on-chain data, using API data:', e);
+                        console.log('[LP Inspect] 链上数据获取失败，使用 API 数据:', e);
+                }
+                // 计算最终价格：优先使用链上价格，否则用 reserve 比例
+                let finalPrice;
+                if (onChainPrice !== undefined) {
+                    finalPrice = onChainPrice;
+                }
+                else if (reserveBase > 0 && reserveQuote > 0) {
+                    // 用储备量比例计算: SOL/代币
+                    finalPrice = reserveQuote / reserveBase;
+                }
+                else {
+                    // API 返回的价格是 代币/SOL，需要取倒数
+                    finalPrice = pool.price ? (1 / pool.price) : undefined;
                 }
                 pools.push({
                     platform,
@@ -469,14 +550,15 @@ async function detectRaydiumPools(mint, connection, debug) {
                     reserveQuoteRaw: BigInt(Math.floor((reserveQuote || 0) * Math.pow(10, quoteDecimals || 9))),
                     reserveBase: String(reserveBase || 0),
                     reserveBaseRaw: BigInt(Math.floor((reserveBase || 0) * Math.pow(10, baseDecimals || 6))),
-                    price: onChainPrice ?? pool.price, // 优先使用链上价格
+                    price: finalPrice,
                     feeBps: Math.floor((pool.feeRate || 0) * 10000),
                     extra: {
                         type: pool.type,
                         programId,
                         tvl: pool.tvl,
                         lpMint: pool.lpMint?.address,
-                        onChainData: onChainPrice !== undefined, // 标记是否使用了链上数据
+                        onChainData: usedOnChainData,
+                        apiPrice: pool.price, // 保留 API 价格用于对比
                     },
                 });
             }
@@ -583,7 +665,9 @@ async function fetchRaydiumPoolOnChain(connection, poolId, programId, debug) {
             try {
                 const poolInfo = PoolInfoLayout.decode(data);
                 // CLMM 使用 sqrtPriceX64 计算价格
-                const price = SqrtPriceMath.sqrtPriceX64ToPrice(poolInfo.sqrtPriceX64, poolInfo.mintDecimalsA, poolInfo.mintDecimalsB);
+                // 注意：合约中 token 是按地址排序的 (token_mint_0 < token_mint_1)
+                // sqrtPriceX64ToPrice 返回 token_1 / token_0
+                const priceFromSqrt = SqrtPriceMath.sqrtPriceX64ToPrice(poolInfo.sqrtPriceX64, poolInfo.mintDecimalsA, poolInfo.mintDecimalsB);
                 // CLMM 的储备量需要从 vault 读取
                 const [vaultAInfo, vaultBInfo] = await connection.getMultipleAccountsInfo([
                     poolInfo.vaultA,
@@ -596,12 +680,32 @@ async function fetchRaydiumPoolOnChain(connection, poolId, programId, debug) {
                     reserveA = Number(vaultAData.amount) / Math.pow(10, poolInfo.mintDecimalsA);
                     reserveB = Number(vaultBData.amount) / Math.pow(10, poolInfo.mintDecimalsB);
                 }
+                // 获取 token mint 地址来判断 token 顺序
+                // poolInfo.mintA 是地址较小的 token (token_mint_0)
+                // poolInfo.mintB 是地址较大的 token (token_mint_1)
+                const mintA = poolInfo.mintA?.toBase58?.() || '';
+                const mintB = poolInfo.mintB?.toBase58?.() || '';
+                if (debug) {
+                    console.log('[LP Inspect] CLMM pool data:', {
+                        mintA,
+                        mintB,
+                        reserveA,
+                        reserveB,
+                        sqrtPriceX64: poolInfo.sqrtPriceX64?.toString(),
+                        priceFromSqrt: priceFromSqrt.toNumber(),
+                    });
+                }
                 return {
                     reserveA,
                     reserveB,
                     decimalsA: poolInfo.mintDecimalsA,
                     decimalsB: poolInfo.mintDecimalsB,
-                    price: price.toNumber(),
+                    // 返回 token_1/token_0 的价格
+                    // detectRaydiumPools 会根据查询的代币位置来决定是否取倒数
+                    price: priceFromSqrt.toNumber(),
+                    // 额外返回 mint 信息，便于 detectRaydiumPools 判断
+                    mintA,
+                    mintB,
                 };
             }
             catch (e) {

package/package.json

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