four-flap-meme-sdk 1.4.20 → 1.4.21

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

@@ -1,900 +0,0 @@
-/**
- * Solana LP 检测工具
- * 自动判断代币在哪个平台（内盘/外盘）
- * @module sol/utils/lp-inspect
- */
-import { PublicKey } from '@solana/web3.js';
-import { createConnection } from './connection.js';
-// ============================================================================
-// 常量
-// ============================================================================
-/** Wrapped SOL */
-const WSOL = 'So11111111111111111111111111111111111111112';
-/** 常用 Quote Token */
-const QUOTE_TOKENS = {
-    [WSOL]: { symbol: 'SOL', decimals: 9 },
-    'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v': { symbol: 'USDC', decimals: 6 },
-    'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB': { symbol: 'USDT', decimals: 6 },
-};
-/** Raydium 程序地址 */
-const RAYDIUM_PROGRAMS = {
-    /** LaunchLab */
-    LAUNCHLAB: 'LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj',
-    /** CPMM (Constant Product) */
-    CPMM: 'CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C',
-    /** Legacy AMM v4 */
-    AMM_V4: '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8',
-    /** Stable Swap AMM */
-    STABLE_SWAP: '5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h',
-    /** CLMM (Concentrated Liquidity) */
-    CLMM: 'CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK',
-};
-// ============================================================================
-// 动态导入（避免循环依赖和类型冲突）
-// ============================================================================
-/** 懒加载 Pump.fun SDK */
-async function loadPumpSdk() {
-    const { getBondingCurveInfo } = await import('../dex/pump/pump.js');
-    const { getPumpSwapPoolInfo } = await import('../dex/pump/pump-swap.js');
-    return { getBondingCurveInfo, getPumpSwapPoolInfo };
-}
-/** 懒加载 Meteora SDK */
-async function loadMeteoraSdk() {
-    const { findDbcPoolByBaseMint, getDbcPoolInfo } = await import('../dex/meteora/dbc.js');
-    const { findDlmmPool, getDlmmPoolInfo, findDlmmPoolsByToken } = await import('../dex/meteora/dlmm.js');
-    return { findDbcPoolByBaseMint, getDbcPoolInfo, findDlmmPool, getDlmmPoolInfo, findDlmmPoolsByToken };
-}
-/** 懒加载 Orca SDK */
-async function loadOrcaSdk() {
-    try {
-        const { getWavebreakBondingCurveInfo } = await import('../dex/orca/wavebreak.js');
-        const { findOrcaPool, getOrcaPoolInfo } = await import('../dex/orca/orca.js');
-        return { getWavebreakBondingCurveInfo, findOrcaPool, getOrcaPoolInfo };
-    }
-    catch {
-        return null;
-    }
-}
-/** 懒加载 Raydium SDK */
-async function loadRaydiumSdk() {
-    try {
-        const { initRaydium, getRaydiumPoolInfo } = await import('../dex/raydium/raydium.js');
-        return { initRaydium, getRaydiumPoolInfo };
-    }
-    catch {
-        return null;
-    }
-}
-// ============================================================================
-// 内盘检测
-// ============================================================================
-/**
- * 检测 Pump.fun Bonding Curve
- */
-async function detectPumpBondingCurve(mint, connection, debug) {
-    try {
-        const { getBondingCurveInfo } = await loadPumpSdk();
-        const info = await getBondingCurveInfo(connection, mint);
-        if (!info)
-            return null;
-        // 计算价格 (virtualSolReserves / virtualTokenReserves)
-        const price = Number(info.virtualSolReserves) / Number(info.virtualTokenReserves);
-        // 计算进度 (realSolReserves / 85 SOL threshold)
-        const GRADUATION_THRESHOLD = 85000000000n; // 85 SOL in lamports
-        const progress = Math.min(100, Number(info.realSolReserves * 100n / GRADUATION_THRESHOLD));
-        return {
-            type: 'pump',
-            address: info.bondingCurve,
-            complete: info.complete,
-            reserveQuote: (Number(info.virtualSolReserves) / 1e9).toFixed(4),
-            reserveQuoteRaw: info.virtualSolReserves,
-            reserveToken: (Number(info.virtualTokenReserves) / 1e6).toFixed(0),
-            reserveTokenRaw: info.virtualTokenReserves,
-            price,
-            progress,
-            creator: info.creator,
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Pump bonding curve check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Meteora DBC
- */
-async function detectMeteoraDbc(mint, connection, debug) {
-    try {
-        const { findDbcPoolByBaseMint, getDbcPoolInfo } = await loadMeteoraSdk();
-        const poolAddress = await findDbcPoolByBaseMint(mint, connection);
-        if (!poolAddress)
-            return null;
-        const poolInfo = await getDbcPoolInfo(poolAddress, connection);
-        return {
-            type: 'meteora_dbc',
-            address: poolAddress,
-            complete: poolInfo.isMigrated,
-            reserveQuote: poolInfo.quoteReserve,
-            reserveQuoteRaw: BigInt(poolInfo.quoteReserve),
-            reserveToken: poolInfo.baseReserve,
-            reserveTokenRaw: BigInt(poolInfo.baseReserve),
-            price: poolInfo.currentPrice,
-            progress: poolInfo.progressPercent,
-            creator: poolInfo.creator,
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Meteora DBC check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Orca Wavebreak
- */
-async function detectOrcaWavebreak(mint, connection, debug) {
-    try {
-        const sdk = await loadOrcaSdk();
-        if (!sdk)
-            return null;
-        const { getWavebreakBondingCurveInfo } = sdk;
-        const info = await getWavebreakBondingCurveInfo(mint, connection);
-        if (!info)
-            return null;
-        return {
-            type: 'orca_wavebreak',
-            address: info.bondingCurveAddress,
-            complete: info.isGraduated,
-            reserveQuote: (Number(info.quoteAmount) / 1e9).toFixed(4),
-            reserveQuoteRaw: info.quoteAmount,
-            reserveToken: info.baseAmount.toString(),
-            reserveTokenRaw: info.baseAmount,
-            price: info.currentPrice,
-            progress: info.progressPercent,
-            creator: info.creator,
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Orca Wavebreak check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Raydium LaunchLab
- * 使用 Raydium SDK 的官方 layout 解析链上数据
- */
-async function detectRaydiumLaunchLab(mint, connection, debug) {
-    try {
-        // 动态导入 Raydium SDK
-        const { LaunchpadPool, LaunchpadConfig, getPdaLaunchpadPoolId, LAUNCHPAD_PROGRAM, Curve, } = await import('@raydium-io/raydium-sdk-v2');
-        const { NATIVE_MINT } = await import('@solana/spl-token');
-        const mintA = new PublicKey(mint);
-        const mintB = NATIVE_MINT; // 默认与 SOL 配对
-        // 获取池子 PDA
-        const poolId = getPdaLaunchpadPoolId(LAUNCHPAD_PROGRAM, mintA, mintB).publicKey;
-        // 获取池子账户数据
-        const poolAccountInfo = await connection.getAccountInfo(poolId);
-        if (!poolAccountInfo) {
-            if (debug)
-                console.log('[LP Inspect] LaunchLab pool not found for mint:', mint);
-            return null;
-        }
-        // 验证程序 ID
-        if (poolAccountInfo.owner.toBase58() !== LAUNCHPAD_PROGRAM.toBase58()) {
-            if (debug)
-                console.log('[LP Inspect] Pool owner is not LaunchLab program');
-            return null;
-        }
-        // 解码池子数据
-        const poolInfo = LaunchpadPool.decode(poolAccountInfo.data);
-        // 获取配置信息
-        const configAccountInfo = await connection.getAccountInfo(poolInfo.configId);
-        if (!configAccountInfo) {
-            if (debug)
-                console.log('[LP Inspect] LaunchLab config not found');
-            return null;
-        }
-        const configInfo = LaunchpadConfig.decode(configAccountInfo.data);
-        // 计算当前价格
-        const currentPrice = Curve.getPrice({
-            poolInfo,
-            curveType: configInfo.curveType,
-            decimalA: poolInfo.mintDecimalsA,
-            decimalB: poolInfo.mintDecimalsB,
-        }).toNumber();
-        // 计算毕业进度
-        let progress = 0;
-        try {
-            const initPrice = Curve.getPoolInitPriceByPool({
-                poolInfo,
-                decimalA: poolInfo.mintDecimalsA,
-                decimalB: poolInfo.mintDecimalsB,
-                curveType: configInfo.curveType,
-            }).toNumber();
-            const endPrice = Curve.getPoolEndPriceReal({
-                poolInfo,
-                curveType: configInfo.curveType,
-                decimalA: poolInfo.mintDecimalsA,
-                decimalB: poolInfo.mintDecimalsB,
-            }).toNumber();
-            const priceDiff = currentPrice - initPrice;
-            const totalDiff = endPrice - initPrice;
-            progress = totalDiff === 0 ? 0 : Math.min((priceDiff / totalDiff) * 100, 100);
-        }
-        catch (e) {
-            if (debug)
-                console.log('[LP Inspect] Failed to calculate LaunchLab progress:', e);
-        }
-        // 判断是否已毕业（迁移到 AMM/CPMM）
-        // 当池子状态变为已迁移或 progress >= 100 时为已完成
-        const isMigrated = poolInfo.status !== undefined && poolInfo.status >= 2; // status: 0=active, 1=waiting, 2+=migrated
-        // 计算储备量
-        // poolInfo 中包含 totalSellA (已卖出的代币) 和 totalFundRaisingB (已筹集的 SOL)
-        const reserveQuote = Number(poolInfo.totalFundRaisingB || 0) / Math.pow(10, poolInfo.mintDecimalsB);
-        const totalSupply = Number(poolInfo.supply || 0) / Math.pow(10, poolInfo.mintDecimalsA);
-        const soldAmount = Number(poolInfo.totalSellA || 0) / Math.pow(10, poolInfo.mintDecimalsA);
-        const reserveToken = totalSupply - soldAmount;
-        return {
-            type: 'raydium_launchlab',
-            address: poolId.toBase58(),
-            complete: isMigrated || progress >= 100,
-            reserveQuote: reserveQuote.toFixed(4),
-            reserveQuoteRaw: BigInt(poolInfo.totalFundRaisingB?.toString() || '0'),
-            reserveToken: reserveToken.toFixed(4),
-            reserveTokenRaw: BigInt(Math.floor(reserveToken * Math.pow(10, poolInfo.mintDecimalsA))),
-            price: currentPrice,
-            progress,
-            creator: poolInfo.creator?.toBase58(),
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Raydium LaunchLab check failed:', err?.message || err);
-        return null;
-    }
-}
-// ============================================================================
-// 外盘检测
-// ============================================================================
-/**
- * 检测 Pump.fun Swap Pool
- */
-async function detectPumpSwapPool(mint, connection, debug) {
-    try {
-        const { getPumpSwapPoolInfo } = await loadPumpSdk();
-        const info = await getPumpSwapPoolInfo(connection, mint);
-        if (!info)
-            return null;
-        // 获取池子余额
-        const poolPubkey = new PublicKey(info.poolAddress);
-        const balance = await connection.getBalance(poolPubkey);
-        return {
-            platform: 'PUMP_SWAP',
-            poolAddress: info.poolAddress,
-            quoteToken: info.quoteMint,
-            quoteSymbol: 'SOL',
-            quoteDecimals: 9,
-            baseToken: info.baseMint,
-            reserveQuote: (balance / 1e9).toFixed(4),
-            reserveQuoteRaw: BigInt(balance),
-            reserveBase: info.lpSupply.toString(),
-            reserveBaseRaw: info.lpSupply,
-            extra: {
-                lpMint: info.lpMint,
-                creator: info.creator,
-            },
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Pump Swap pool check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Meteora DLMM Pool
- * 优化: 使用 Meteora API 替代全量链上查询
- */
-async function detectMeteoraDlmm(mint, connection, debug) {
-    try {
-        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;
-        }
-        // 优先选择与 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: selectedPool.address,
-            quoteToken,
-            quoteSymbol: quoteToken === WSOL ? 'SOL' : 'UNKNOWN',
-            quoteDecimals: quoteToken === WSOL ? 9 : 6,
-            baseToken: mint,
-            reserveQuote: reserveQuote || '0',
-            reserveQuoteRaw: BigInt(reserveQuote || 0),
-            reserveBase: reserveBase || '0',
-            reserveBaseRaw: BigInt(reserveBase || 0),
-            price: poolInfo.currentPrice,
-            feeBps: poolInfo.feeBps,
-            extra: {
-                binStep: poolInfo.binStep,
-                activeId: poolInfo.activeId,
-            },
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Meteora DLMM check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Orca Whirlpool
- */
-async function detectOrcaWhirlpool(mint, connection, debug) {
-    try {
-        const sdk = await loadOrcaSdk();
-        if (!sdk)
-            return null;
-        const { findOrcaPool, getOrcaPoolInfo } = sdk;
-        // 尝试与 SOL 配对（常见的 tick spacing: 64, 128）
-        let poolAddress = await findOrcaPool(mint, WSOL, 64, connection);
-        if (!poolAddress) {
-            poolAddress = await findOrcaPool(mint, WSOL, 128, connection);
-        }
-        if (!poolAddress)
-            return null;
-        const poolInfo = await getOrcaPoolInfo(poolAddress, connection);
-        // 判断哪个是 base token
-        const isTokenA = poolInfo.tokenMintA === mint;
-        return {
-            platform: 'ORCA_WHIRLPOOL',
-            poolAddress,
-            quoteToken: isTokenA ? poolInfo.tokenMintB : poolInfo.tokenMintA,
-            quoteSymbol: 'SOL',
-            quoteDecimals: isTokenA ? poolInfo.tokenDecimalsB : poolInfo.tokenDecimalsA,
-            baseToken: mint,
-            reserveQuote: '0', // Whirlpool 需要通过 vault 查询
-            reserveQuoteRaw: 0n,
-            reserveBase: '0',
-            reserveBaseRaw: 0n,
-            price: poolInfo.price,
-            feeBps: poolInfo.feeRate,
-            extra: {
-                tickSpacing: poolInfo.tickSpacing,
-                currentTick: poolInfo.currentTick,
-                liquidity: poolInfo.liquidity,
-            },
-        };
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Orca Whirlpool check failed:', err);
-        return null;
-    }
-}
-/**
- * 检测 Raydium 池子（混合方案）
- * 1. 先用 API 快速发现池子列表
- * 2. 再用链上查询获取实时储备量
- */
-async function detectRaydiumPools(mint, connection, debug) {
-    const pools = [];
-    try {
-        // ==================== 步骤 1: 用 API 发现池子 ====================
-        const apiUrl = `https://api-v3.raydium.io/pools/info/mint?mint1=${mint}&poolType=all&poolSortField=default&sortType=desc&pageSize=20&page=1`;
-        const response = await fetch(apiUrl);
-        if (!response.ok) {
-            if (debug)
-                console.log('[LP Inspect] Raydium API request failed:', response.status);
-            return pools;
-        }
-        const result = await response.json();
-        if (!result.success || !result.data?.data) {
-            if (debug)
-                console.log('[LP Inspect] Raydium API returned no data');
-            return pools;
-        }
-        const poolArray = result.data.data;
-        if (!Array.isArray(poolArray) || poolArray.length === 0)
-            return pools;
-        if (debug)
-            console.log('[LP Inspect] Raydium API found', poolArray.length, 'pools');
-        // ==================== 步骤 2: 链上查询实时数据 ====================
-        for (const pool of poolArray) {
-            try {
-                // 判断池子类型和程序
-                let platform = 'RAYDIUM_AMM';
-                const programId = pool.programId;
-                if (programId === RAYDIUM_PROGRAMS.CPMM) {
-                    platform = 'RAYDIUM_CPMM';
-                }
-                else if (programId === RAYDIUM_PROGRAMS.CLMM) {
-                    platform = 'RAYDIUM_CLMM';
-                }
-                else if (programId === RAYDIUM_PROGRAMS.AMM_V4) {
-                    platform = 'RAYDIUM_AMM';
-                }
-                // 判断哪个是 base token
-                const isBaseA = pool.mintA?.address === mint;
-                const quoteToken = isBaseA ? pool.mintB?.address : pool.mintA?.address;
-                const quoteSymbol = isBaseA ? pool.mintB?.symbol : pool.mintA?.symbol;
-                const quoteDecimals = isBaseA ? pool.mintB?.decimals : pool.mintA?.decimals;
-                const baseDecimals = isBaseA ? pool.mintA?.decimals : pool.mintB?.decimals;
-                if (!quoteToken)
-                    continue;
-                // 尝试从链上获取实时储备量
-                let reserveQuote = pool.mintAmountA;
-                let reserveBase = pool.mintAmountB;
-                if (isBaseA) {
-                    reserveQuote = pool.mintAmountB;
-                    reserveBase = pool.mintAmountA;
-                }
-                // 尝试从链上获取实时数据（支持 CPMM, AMM V4, CLMM）
-                let onChainPrice;
-                let usedOnChainData = false;
-                try {
-                    const onChainData = await fetchRaydiumPoolOnChain(connection, pool.id, programId, debug); // 添加类型断言以访问额外属性
-                    if (onChainData) {
-                        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 {
-                            // 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,
-                            });
-                        }
-                    }
-                }
-                catch (e) {
-                    if (debug)
-                        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,
-                    poolAddress: pool.id,
-                    quoteToken: quoteToken || '',
-                    quoteSymbol: quoteSymbol || 'UNKNOWN',
-                    quoteDecimals: quoteDecimals || 9,
-                    baseToken: mint,
-                    reserveQuote: String(reserveQuote || 0),
-                    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: finalPrice,
-                    feeBps: Math.floor((pool.feeRate || 0) * 10000),
-                    extra: {
-                        type: pool.type,
-                        programId,
-                        tvl: pool.tvl,
-                        lpMint: pool.lpMint?.address,
-                        onChainData: usedOnChainData,
-                        apiPrice: pool.price, // 保留 API 价格用于对比
-                    },
-                });
-            }
-            catch (poolErr) {
-                if (debug)
-                    console.log('[LP Inspect] Error processing pool:', pool.id, poolErr);
-            }
-        }
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Raydium pools check failed:', err);
-    }
-    return pools;
-}
-/**
- * 从链上获取 Raydium 池子的实时数据
- * 使用 Raydium SDK 的官方 layout 解析
- */
-async function fetchRaydiumPoolOnChain(connection, poolId, programId, debug) {
-    try {
-        // 动态导入 Raydium SDK 的 layout
-        const { liquidityStateV4Layout, CpmmPoolInfoLayout, PoolInfoLayout, splAccountLayout, SqrtPriceMath, } = await import('@raydium-io/raydium-sdk-v2');
-        const poolPubkey = new PublicKey(poolId);
-        const accountInfo = await connection.getAccountInfo(poolPubkey);
-        if (!accountInfo) {
-            if (debug)
-                console.log('[LP Inspect] Pool account not found:', poolId);
-            return null;
-        }
-        // 验证程序 ID
-        if (accountInfo.owner.toBase58() !== programId) {
-            if (debug)
-                console.log('[LP Inspect] Pool owner mismatch');
-            return null;
-        }
-        const data = accountInfo.data;
-        // ==================== CPMM 池子 ====================
-        if (programId === RAYDIUM_PROGRAMS.CPMM) {
-            try {
-                const poolInfo = CpmmPoolInfoLayout.decode(data);
-                // 读取 vault 账户余额
-                const [vaultAInfo, vaultBInfo] = await connection.getMultipleAccountsInfo([
-                    poolInfo.vaultA,
-                    poolInfo.vaultB,
-                ]);
-                if (!vaultAInfo || !vaultBInfo)
-                    return null;
-                const vaultAData = splAccountLayout.decode(vaultAInfo.data);
-                const vaultBData = splAccountLayout.decode(vaultBInfo.data);
-                // 计算实际储备 (扣除手续费)
-                const reserveA = Number(vaultAData.amount
-                    .sub(poolInfo.fundFeesMintA)
-                    .sub(poolInfo.protocolFeesMintA)) / Math.pow(10, poolInfo.mintDecimalA);
-                const reserveB = Number(vaultBData.amount
-                    .sub(poolInfo.fundFeesMintB)
-                    .sub(poolInfo.protocolFeesMintB)) / Math.pow(10, poolInfo.mintDecimalB);
-                return {
-                    reserveA,
-                    reserveB,
-                    decimalsA: poolInfo.mintDecimalA,
-                    decimalsB: poolInfo.mintDecimalB,
-                    price: reserveB / reserveA,
-                };
-            }
-            catch (e) {
-                if (debug)
-                    console.log('[LP Inspect] CPMM decode error:', e);
-                return null;
-            }
-        }
-        // ==================== AMM V4 池子 ====================
-        else if (programId === RAYDIUM_PROGRAMS.AMM_V4) {
-            try {
-                const poolInfo = liquidityStateV4Layout.decode(data);
-                // 读取 vault 账户余额
-                const [baseVaultInfo, quoteVaultInfo] = await connection.getMultipleAccountsInfo([
-                    poolInfo.baseVault,
-                    poolInfo.quoteVault,
-                ]);
-                if (!baseVaultInfo || !quoteVaultInfo)
-                    return null;
-                const baseVaultData = splAccountLayout.decode(baseVaultInfo.data);
-                const quoteVaultData = splAccountLayout.decode(quoteVaultInfo.data);
-                // 计算实际储备 (扣除待提取的 PnL)
-                const reserveA = Number(baseVaultData.amount.sub(poolInfo.baseNeedTakePnl)) / Math.pow(10, poolInfo.baseDecimal.toNumber());
-                const reserveB = Number(quoteVaultData.amount.sub(poolInfo.quoteNeedTakePnl)) / Math.pow(10, poolInfo.quoteDecimal.toNumber());
-                return {
-                    reserveA,
-                    reserveB,
-                    decimalsA: poolInfo.baseDecimal.toNumber(),
-                    decimalsB: poolInfo.quoteDecimal.toNumber(),
-                    price: reserveB / reserveA,
-                };
-            }
-            catch (e) {
-                if (debug)
-                    console.log('[LP Inspect] AMM V4 decode error:', e);
-                return null;
-            }
-        }
-        // ==================== CLMM 池子 ====================
-        else if (programId === RAYDIUM_PROGRAMS.CLMM) {
-            try {
-                const poolInfo = PoolInfoLayout.decode(data);
-                // CLMM 使用 sqrtPriceX64 计算价格
-                // 注意：合约中 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,
-                    poolInfo.vaultB,
-                ]);
-                let reserveA = 0, reserveB = 0;
-                if (vaultAInfo && vaultBInfo) {
-                    const vaultAData = splAccountLayout.decode(vaultAInfo.data);
-                    const vaultBData = splAccountLayout.decode(vaultBInfo.data);
-                    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,
-                    // 返回 token_1/token_0 的价格
-                    // detectRaydiumPools 会根据查询的代币位置来决定是否取倒数
-                    price: priceFromSqrt.toNumber(),
-                    // 额外返回 mint 信息，便于 detectRaydiumPools 判断
-                    mintA,
-                    mintB,
-                };
-            }
-            catch (e) {
-                if (debug)
-                    console.log('[LP Inspect] CLMM decode error:', e);
-                return null;
-            }
-        }
-        return null;
-    }
-    catch (e) {
-        if (debug)
-            console.log('[LP Inspect] On-chain fetch error:', e);
-        return null;
-    }
-}
-// ============================================================================
-// 主函数
-// ============================================================================
-/**
- * 检测 Solana 代币的 LP 所在平台
- *
- * @param mint 代币 Mint 地址
- * @param options 检测选项
- * @returns LP 信息
- *
- * @example
- * ```typescript
- * const lpInfo = await inspectSolanaTokenLP('TokenMintAddress...', {
- *   rpcUrl: 'https://api.mainnet-beta.solana.com',
- *   debug: true,
- * })
- *
- * if (lpInfo.platform === 'PUMP_BONDING_CURVE') {
- *   console.log('代币在 Pump.fun 内盘')
- *   console.log('毕业进度:', lpInfo.bondingCurve?.progress)
- * } else if (lpInfo.bestPool) {
- *   console.log('最佳池子:', lpInfo.bestPool.platform)
- *   console.log('流动性:', lpInfo.bestPool.reserveQuote)
- * }
- * ```
- */
-export async function inspectSolanaTokenLP(mint, options = {}) {
-    const startTime = Date.now();
-    if (!options.connection && !options.rpcUrl) {
-        throw new Error('Either connection or rpcUrl is required in options');
-    }
-    const connection = options.connection || createConnection(options.rpcUrl);
-    const debug = options.debug;
-    // 初始化结果
-    const result = {
-        mint,
-        platform: 'UNKNOWN',
-        pools: [],
-    };
-    // 获取代币信息
-    try {
-        const mintPubkey = new PublicKey(mint);
-        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
-        if (mintInfo.value?.data && 'parsed' in mintInfo.value.data) {
-            const parsed = mintInfo.value.data.parsed;
-            const decimals = parsed.info.decimals;
-            result.decimals = decimals;
-            result.totalSupplyRaw = BigInt(parsed.info.supply);
-            result.totalSupply = (Number(result.totalSupplyRaw) / Math.pow(10, decimals)).toString();
-        }
-    }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Failed to get mint info:', err);
-    }
-    // ========================================
-    // 1. 内盘检测（并行）
-    // ========================================
-    if (!options.skipBondingCurve) {
-        const bondingCurveResults = await Promise.allSettled([
-            detectPumpBondingCurve(mint, connection, debug),
-            detectMeteoraDbc(mint, connection, debug),
-            detectOrcaWavebreak(mint, connection, debug),
-            detectRaydiumLaunchLab(mint, connection, debug),
-        ]);
-        // 查找第一个有效的内盘
-        for (const r of bondingCurveResults) {
-            if (r.status === 'fulfilled' && r.value && !r.value.complete) {
-                result.bondingCurve = r.value;
-                // 设置平台类型
-                switch (r.value.type) {
-                    case 'pump':
-                        result.platform = 'PUMP_BONDING_CURVE';
-                        break;
-                    case 'meteora_dbc':
-                        result.platform = 'METEORA_DBC';
-                        break;
-                    case 'orca_wavebreak':
-                        result.platform = 'ORCA_WAVEBREAK';
-                        break;
-                    case 'raydium_launchlab':
-                        result.platform = 'RAYDIUM_LAUNCHLAB';
-                        break;
-                }
-                result.elapsed = Date.now() - startTime;
-                return result;
-            }
-        }
-    }
-    // ========================================
-    // 2. 外盘检测（并行）
-    // ========================================
-    if (!options.skipPools) {
-        const poolResults = await Promise.allSettled([
-            detectPumpSwapPool(mint, connection, debug),
-            detectMeteoraDlmm(mint, connection, debug),
-            detectOrcaWhirlpool(mint, connection, debug),
-            detectRaydiumPools(mint, connection, debug),
-        ]);
-        // 收集所有有效的池子
-        for (const r of poolResults) {
-            if (r.status === 'fulfilled' && r.value) {
-                if (Array.isArray(r.value)) {
-                    result.pools.push(...r.value);
-                }
-                else {
-                    result.pools.push(r.value);
-                }
-            }
-        }
-        // 按流动性排序
-        result.pools.sort((a, b) => {
-            const liquidityA = Number(a.reserveQuoteRaw);
-            const liquidityB = Number(b.reserveQuoteRaw);
-            return liquidityB - liquidityA;
-        });
-        // 设置最佳池子
-        if (result.pools.length > 0) {
-            result.bestPool = result.pools[0];
-            // 设置平台类型
-            if (result.pools.length > 1) {
-                result.platform = 'MULTI_POOL';
-            }
-            else {
-                result.platform = result.bestPool.platform;
-            }
-        }
-    }
-    result.elapsed = Date.now() - startTime;
-    return result;
-}
-/**
- * 快速检测代币是否在内盘
- *
- * @param mint 代币 Mint 地址
- * @param options 检测选项
- * @returns 如果在内盘返回内盘信息，否则返回 null
- */
-export async function detectBondingCurve(mint, options = {}) {
-    if (!options.connection && !options.rpcUrl) {
-        throw new Error('Either connection or rpcUrl is required in options');
-    }
-    const connection = options.connection || createConnection(options.rpcUrl);
-    const debug = options.debug;
-    // 并行检测所有内盘
-    const results = await Promise.allSettled([
-        detectPumpBondingCurve(mint, connection, debug),
-        detectMeteoraDbc(mint, connection, debug),
-        detectOrcaWavebreak(mint, connection, debug),
-        detectRaydiumLaunchLab(mint, connection, debug),
-    ]);
-    // 返回第一个未毕业的内盘
-    for (const r of results) {
-        if (r.status === 'fulfilled' && r.value && !r.value.complete) {
-            return r.value;
-        }
-    }
-    return null;
-}
-/**
- * 判断代币是否已毕业（不在任何内盘）
- */
-export async function isTokenGraduated(mint, options = {}) {
-    const bondingCurve = await detectBondingCurve(mint, options);
-    return bondingCurve === null;
-}
-/**
- * 获取代币的最佳交易池
- */
-export async function getBestPool(mint, options = {}) {
-    const lpInfo = await inspectSolanaTokenLP(mint, {
-        ...options,
-        skipBondingCurve: true,
-    });
-    return lpInfo.bestPool || null;
-}