four-flap-meme-sdk 1.5.54 → 1.5.56

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

@@ -5,125 +5,71 @@
  */
 import { Connection } from '@solana/web3.js';
 /** Solana LP 平台类型 */
-export type SolanaLPPlatform = 'PUMP_BONDING_CURVE' | 'METEORA_DBC' | 'ORCA_WAVEBREAK' | 'RAYDIUM_LAUNCHLAB' | 'PUMP_SWAP' | 'METEORA_DLMM' | 'METEORA_DAMM_V1' | 'METEORA_DAMM_V2' | 'ORCA_WHIRLPOOL' | 'RAYDIUM_AMM' | 'RAYDIUM_CPMM' | 'RAYDIUM_CLMM' | 'MULTI_POOL' | 'UNKNOWN';
+export type SolanaLPPlatform = 'PUMP_BONDING_CURVE' | 'METEORA_DBC' | 'RAYDIUM_LAUNCHLAB' | 'JUPITER_AGGREGATED' | 'PUMP_SWAP' | 'MULTI_POOL' | 'UNKNOWN';
 /** 内盘（Bonding Curve）信息 */
 export interface SolanaBondingCurveInfo {
-    /** 平台类型 */
-    type: 'pump' | 'meteora_dbc' | 'orca_wavebreak' | 'raydium_launchlab';
-    /** Bonding Curve 地址 */
+    type: 'pump' | 'meteora_dbc' | 'raydium_launchlab';
     address: string;
-    /** 是否已毕业/迁移 */
     complete: boolean;
-    /** Quote Token 储备（SOL 或其他） */
     reserveQuote: string;
     reserveQuoteRaw: bigint;
-    /** Base Token 储备 */
     reserveToken: string;
     reserveTokenRaw: bigint;
-    /** 当前价格 */
     price?: number;
-    /** 毕业进度百分比 */
     progress?: number;
-    /** 创建者 */
     creator?: string;
 }
-/** 外盘池子信息 */
+/** 外盘池子信息 (整合 Jupiter 数据) */
 export interface SolanaPoolInfo {
-    /** 平台类型 */
     platform: SolanaLPPlatform;
-    /** 池子地址 */
     poolAddress: string;
-    /** Quote Token（SOL/USDC 等）*/
     quoteToken: string;
     quoteSymbol: string;
     quoteDecimals: number;
-    /** Base Token */
     baseToken: string;
-    /** Quote 储备 */
     reserveQuote: string;
     reserveQuoteRaw: bigint;
-    /** Base 储备 */
-    reserveBase: string;
-    reserveBaseRaw: bigint;
-    /** 当前价格 */
     price?: number;
-    /** 费率 (bps) */
-    feeBps?: number;
-    /** 额外信息（如 tick spacing、bin step 等）*/
+    mcap?: number;
+    liquidity?: number;
+    fdv?: number;
+    isVerified?: boolean;
     extra?: Record<string, any>;
 }
 /** Solana LP 检测结果 */
 export interface SolanaLPInfo {
-    /** 代币 Mint 地址 */
     mint: string;
-    /** 主平台类型 */
     platform: SolanaLPPlatform;
-    /** 代币精度 */
     decimals?: number;
-    /** 代币总供应量 */
     totalSupply?: string;
     totalSupplyRaw?: bigint;
-    /** 内盘信息（如果在内盘） */
     bondingCurve?: SolanaBondingCurveInfo;
-    /** 所有发现的外盘池子 */
-    pools: SolanaPoolInfo[];
-    /** 最佳池子推荐（按流动性排序） */
     bestPool?: SolanaPoolInfo;
-    /** 检测耗时 (ms) */
+    pools: SolanaPoolInfo[];
     elapsed?: number;
 }
 /** 检测选项 */
 export interface SolanaInspectOptions {
-    /** 自定义 RPC URL */
     rpcUrl?: string;
-    /** 自定义连接 */
     connection?: Connection;
-    /** 是否跳过内盘检测 */
     skipBondingCurve?: boolean;
-    /** 是否跳过外盘检测 */
     skipPools?: boolean;
-    /** 调试模式 */
     debug?: boolean;
-    /** 超时时间 (ms) */
     timeout?: number;
 }
 /**
- * 检测 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)
- * }
- * ```
+ * 检测 Solana 代币的 LP 信息
  */
 export declare function inspectSolanaTokenLP(mint: string, options?: SolanaInspectOptions): Promise<SolanaLPInfo>;
 /**
  * 快速检测代币是否在内盘
- *
- * @param mint 代币 Mint 地址
- * @param options 检测选项
- * @returns 如果在内盘返回内盘信息，否则返回 null
  */
 export declare function detectBondingCurve(mint: string, options?: SolanaInspectOptions): Promise<SolanaBondingCurveInfo | null>;
 /**
- * 判断代币是否已毕业（不在任何内盘）
+ * 获取代币流动性 (USD)
  */
-export declare function isTokenGraduated(mint: string, options?: SolanaInspectOptions): Promise<boolean>;
+export declare function getTokenLiquidity(mint: string, options?: SolanaInspectOptions): Promise<number>;
 /**
- * 获取代币的最佳交易池
+ * 判断代币是否已毕业
  */
-export declare function getBestPool(mint: string, options?: SolanaInspectOptions): Promise<SolanaPoolInfo | null>;
+export declare function isTokenGraduated(mint: string, options?: SolanaInspectOptions): Promise<boolean>;

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

@@ -5,66 +5,11 @@
  */
 import { PublicKey } from '@solana/web3.js';
 import { createConnection } from './connection.js';
+import { getTokenInfoV2 } from '../dex/jup/tokens.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;
-    }
-}
 // ============================================================================
 // 内盘检测
 // ============================================================================
@@ -73,14 +18,12 @@ async function loadRaydiumSdk() {
  */
 async function detectPumpBondingCurve(mint, connection, debug) {
     try {
-        const { getBondingCurveInfo } = await loadPumpSdk();
+        const { getBondingCurveInfo } = await import('../dex/pump/pump.js');
         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 GRADUATION_THRESHOLD = 85000000000n;
         const progress = Math.min(100, Number(info.realSolReserves * 100n / GRADUATION_THRESHOLD));
         return {
             type: 'pump',
@@ -106,7 +49,7 @@ async function detectPumpBondingCurve(mint, connection, debug) {
  */
 async function detectMeteoraDbc(mint, connection, debug) {
     try {
-        const { findDbcPoolByBaseMint, getDbcPoolInfo } = await loadMeteoraSdk();
+        const { findDbcPoolByBaseMint, getDbcPoolInfo } = await import('../dex/meteora/dbc.js');
         const poolAddress = await findDbcPoolByBaseMint(mint, connection);
         if (!poolAddress)
             return null;
@@ -130,595 +73,83 @@ async function detectMeteoraDbc(mint, connection, debug) {
         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 poolId = getPdaLaunchpadPoolId(LAUNCHPAD_PROGRAM, new PublicKey(mint), NATIVE_MINT).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');
+        if (!poolAccountInfo)
             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');
+        if (!configAccountInfo)
             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;
+        const isMigrated = poolInfo.status !== undefined && poolInfo.status >= 2;
         return {
             type: 'raydium_launchlab',
             address: poolId.toBase58(),
-            complete: isMigrated || progress >= 100,
-            reserveQuote: reserveQuote.toFixed(4),
+            complete: isMigrated,
+            reserveQuote: (Number(poolInfo.totalFundRaisingB || 0) / 1e9).toFixed(4),
             reserveQuoteRaw: BigInt(poolInfo.totalFundRaisingB?.toString() || '0'),
-            reserveToken: reserveToken.toFixed(4),
-            reserveTokenRaw: BigInt(Math.floor(reserveToken * Math.pow(10, poolInfo.mintDecimalsA))),
+            reserveToken: "0", // Simplified
+            reserveTokenRaw: 0n,
             price: currentPrice,
-            progress,
             creator: poolInfo.creator?.toBase58(),
         };
     }
     catch (err) {
         if (debug)
-            console.log('[LP Inspect] Raydium LaunchLab check failed:', err?.message || err);
+            console.log('[LP Inspect] Raydium LaunchLab check failed:', err);
         return null;
     }
 }
 // ============================================================================
-// 外盘检测
+// 外盘检测 (Jupiter API)
 // ============================================================================
 /**
- * 检测 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
+ * 使用 Jupiter API 检测外盘信息
  */
-async function detectOrcaWhirlpool(mint, connection, debug) {
+async function detectWithJupiter(mint, debug) {
     try {
-        const sdk = await loadOrcaSdk();
-        if (!sdk)
+        const info = await getTokenInfoV2(mint);
+        if (!info || !info.liquidity || info.liquidity < 100) {
             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,
+            platform: 'JUPITER_AGGREGATED',
+            poolAddress: info.graduatedPool || '',
+            quoteToken: WSOL,
             quoteSymbol: 'SOL',
-            quoteDecimals: isTokenA ? poolInfo.tokenDecimalsB : poolInfo.tokenDecimalsA,
+            quoteDecimals: 9,
             baseToken: mint,
-            reserveQuote: '0', // Whirlpool 需要通过 vault 查询
-            reserveQuoteRaw: 0n,
-            reserveBase: '0',
-            reserveBaseRaw: 0n,
-            price: poolInfo.price,
-            feeBps: poolInfo.feeRate,
+            reserveQuote: info.liquidity.toFixed(2),
+            reserveQuoteRaw: BigInt(Math.floor(info.liquidity)),
+            price: info.usdPrice ?? undefined,
+            mcap: info.mcap ?? undefined,
+            liquidity: info.liquidity,
+            fdv: info.fdv ?? undefined,
+            isVerified: info.isVerified ?? false,
             extra: {
-                tickSpacing: poolInfo.tickSpacing,
-                currentTick: poolInfo.currentTick,
-                liquidity: poolInfo.liquidity,
-            },
+                launchpad: info.launchpad,
+                organicScore: info.organicScore,
+                stats24h: info.stats24h,
+            }
         };
     }
     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);
+            console.log('[LP Inspect] Jupiter check failed:', err);
         return null;
     }
 }
@@ -726,128 +157,51 @@ async function fetchRaydiumPoolOnChain(connection, poolId, programId, debug) {
 // 主函数
 // ============================================================================
 /**
- * 检测 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)
- * }
- * ```
+ * 检测 Solana 代币的 LP 信息
  */
 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: [],
     };
-    // 获取代币信息
+    // 0. 获取代币基本信息
     try {
-        const mintPubkey = new PublicKey(mint);
-        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const mintInfo = await connection.getParsedAccountInfo(new PublicKey(mint));
         if (mintInfo.value?.data && 'parsed' in mintInfo.value.data) {
             const parsed = mintInfo.value.data.parsed;
-            const decimals = parsed.info.decimals;
-            result.decimals = decimals;
+            result.decimals = parsed.info.decimals;
             result.totalSupplyRaw = BigInt(parsed.info.supply);
-            result.totalSupply = (Number(result.totalSupplyRaw) / Math.pow(10, decimals)).toString();
+            result.totalSupply = (Number(result.totalSupplyRaw) / Math.pow(10, result.decimals)).toString();
         }
     }
-    catch (err) {
-        if (debug)
-            console.log('[LP Inspect] Failed to get mint info:', err);
-    }
-    // ========================================
-    // 1. 内盘检测（并行）
-    // ========================================
+    catch { }
+    // 1. 内盘检测
     if (!options.skipBondingCurve) {
-        const bondingCurveResults = await Promise.allSettled([
+        const [pump, meteora, raydium] = await Promise.all([
             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;
-            }
+        const bc = pump || meteora || raydium;
+        if (bc && !bc.complete) {
+            result.bondingCurve = bc;
+            result.platform = bc.type === 'pump' ? 'PUMP_BONDING_CURVE' :
+                bc.type === 'meteora_dbc' ? 'METEORA_DBC' : 'RAYDIUM_LAUNCHLAB';
+            result.elapsed = Date.now() - startTime;
+            return result;
         }
     }
-    // ========================================
-    // 2. 外盘检测（并行）
-    // ========================================
+    // 2. 外盘检测 (Jupiter)
     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;
-            }
+        const jupPool = await detectWithJupiter(mint, debug);
+        if (jupPool) {
+            result.bestPool = jupPool;
+            result.pools = [jupPool];
+            result.platform = jupPool.platform;
         }
     }
     result.elapsed = Date.now() - startTime;
@@ -855,46 +209,27 @@ export async function inspectSolanaTokenLP(mint, options = {}) {
 }
 /**
  * 快速检测代币是否在内盘
- *
- * @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),
+    const results = await Promise.all([
+        detectPumpBondingCurve(mint, connection, options.debug),
+        detectMeteoraDbc(mint, connection, options.debug),
+        detectRaydiumLaunchLab(mint, connection, options.debug),
     ]);
-    // 返回第一个未毕业的内盘
-    for (const r of results) {
-        if (r.status === 'fulfilled' && r.value && !r.value.complete) {
-            return r.value;
-        }
-    }
-    return null;
+    return results.find(r => r && !r.complete) || null;
 }
 /**
- * 判断代币是否已毕业（不在任何内盘）
+ * 获取代币流动性 (USD)
  */
-export async function isTokenGraduated(mint, options = {}) {
-    const bondingCurve = await detectBondingCurve(mint, options);
-    return bondingCurve === null;
+export async function getTokenLiquidity(mint, options = {}) {
+    const info = await inspectSolanaTokenLP(mint, options);
+    return info.bestPool?.liquidity || 0;
 }
 /**
- * 获取代币的最佳交易池
+ * 判断代币是否已毕业
  */
-export async function getBestPool(mint, options = {}) {
-    const lpInfo = await inspectSolanaTokenLP(mint, {
-        ...options,
-        skipBondingCurve: true,
-    });
-    return lpInfo.bestPool || null;
+export async function isTokenGraduated(mint, options = {}) {
+    const bc = await detectBondingCurve(mint, options);
+    return bc === null;
 }

package/dist/utils/constants.d.ts

@@ -16,13 +16,13 @@ export declare const PROFIT_CONFIG: {
     /** 利润接收地址 */
     readonly RECIPIENT: "0x8a365e4359247D7FdbE8a73B547566A03E4e9Ed8";
     /** 利润比例（基点）：30 bps = 0.3% = 千分之三（普通模式） */
-    readonly RATE_BPS: 30;
+    readonly RATE_BPS: 40;
     /** 利润比例（基点）：6 bps = 0.06% = 万分之六（捆绑换手模式） */
     readonly RATE_BPS_SWAP: 6;
     /** 利润比例（单边基点）：6 bps = 0.06% = 万分之六（用户类型 v0） */
-    readonly RATE_BPS_V0: 6;
+    readonly RATE_BPS_V0: 8;
     /** 利润比例（双边基点）：3 bps = 0.03% = 千分之三（用户类型 v0） */
-    readonly RATE_BPS_V0_DOUBLE: 3;
+    readonly RATE_BPS_V0_DOUBLE: 4;
     /** 利润比例（单边基点）：5 bps = 0.05% = 万分之五（用户类型 v1） */
     readonly RATE_BPS_V1: 10;
     /** 利润比例（双边基点）：2.5 bps = 0.025% = 千分之二点五（用户类型 v1） */

package/dist/utils/constants.js

@@ -22,13 +22,13 @@ export const PROFIT_CONFIG = {
     /** 利润接收地址 */
     RECIPIENT: '0x8a365e4359247D7FdbE8a73B547566A03E4e9Ed8',
     /** 利润比例（基点）：30 bps = 0.3% = 千分之三（普通模式） */
-    RATE_BPS: 30,
+    RATE_BPS: 40,
     /** 利润比例（基点）：6 bps = 0.06% = 万分之六（捆绑换手模式） */
     RATE_BPS_SWAP: 6,
     /** 利润比例（单边基点）：6 bps = 0.06% = 万分之六（用户类型 v0） */
-    RATE_BPS_V0: 6,
+    RATE_BPS_V0: 8,
     /** 利润比例（双边基点）：3 bps = 0.03% = 千分之三（用户类型 v0） */
-    RATE_BPS_V0_DOUBLE: 3,
+    RATE_BPS_V0_DOUBLE: 4,
     /** 利润比例（单边基点）：5 bps = 0.05% = 万分之五（用户类型 v1） */
     RATE_BPS_V1: 10,
     /** 利润比例（双边基点）：2.5 bps = 0.025% = 千分之二点五（用户类型 v1） */

package/dist/xlayer/bundle.js

@@ -1462,7 +1462,7 @@ export class BundleExecutor {
         const curveBuyData = curveBuyerWallets.map((wallet, i) => {
             const buyWei = parseOkb(curveBuyAmounts[i]);
             const isLast = i === curveBuyerWallets.length - 1;
-            const gasLimit = isLast ? 8000000n : 800000n; // 最后一笔触发毕业，给大一点
+            const gasLimit = 8000000n; // 统一给 800W，不再区分是否最后一笔
             return { wallet, info: curveBuyerInfos[i], buyWei, gasLimit };
         });
         totalCurveBuyWei = curveBuyData.reduce((sum, d) => sum + d.buyWei, 0n);

package/package.json

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