@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

package/dist/src/services/PlatformStatsService.d.ts

@@ -1,72 +0,0 @@
-/**
- * Platform Stats Service
- *
- * Handles platform-wide statistics including trading volume and token counts.
- *
- * @category Services
- * @since 9.0.0
- */
-import type { GetPlatformStatsResult } from '../types/platform-stats.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-/**
- * Platform Stats Service Class
- *
- * Provides methods for accessing platform-wide statistics:
- * - Total GALA trading volume (1h, 24h, 7d)
- * - Total token count
- *
- * **Caching:**
- * Backend caches stats for 3 minutes. HTTP responses include Cache-Control
- * headers (60s max-age).
- *
- * **Public endpoint** - no authentication required.
- *
- * @example
- * ```typescript
- * const statsService = new PlatformStatsService(httpClient, true);
- *
- * // Get platform stats
- * const { stats } = await statsService.getStats();
- * console.log('Volume (1h):', stats.galaVolume1h, 'GALA');
- * console.log('Volume (24h):', stats.galaVolume24h, 'GALA');
- * console.log('Volume (7d):', stats.galaVolume7d, 'GALA');
- * console.log('Total tokens:', stats.totalTokens);
- * console.log('Updated:', stats.timestamp);
- * ```
- */
-export declare class PlatformStatsService extends BaseService {
-    constructor(http: HttpClient, debugMode?: boolean);
-    /**
-     * Extract data from API response wrapper
-     * @throws Error if response indicates failure or has no data
-     */
-    private extractData;
-    /**
-     * Get platform-wide statistics
-     *
-     * Returns aggregated platform metrics including:
-     * - GALA trading volume over 1h, 24h, 7d
-     * - Total number of tokens on the platform
-     *
-     * @returns Platform statistics
-     *
-     * @example
-     * ```typescript
-     * const { stats } = await statsService.getStats();
-     *
-     * // Display volume in millions
-     * const vol24h = parseFloat(stats.galaVolume24h);
-     * console.log(`24h Volume: ${(vol24h / 1_000_000).toFixed(2)}M GALA`);
-     *
-     * // Display token count
-     * console.log(`${stats.totalTokens} tokens on platform`);
-     *
-     * // Display timestamp
-     * const updated = new Date(stats.timestamp);
-     * console.log(`Last updated: ${updated.toLocaleString()}`);
-     * ```
-     */
-    getStats(): Promise<GetPlatformStatsResult>;
-}
-//# sourceMappingURL=PlatformStatsService.d.ts.map

package/dist/src/services/PlatformStatsService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PlatformStatsService.d.ts","sourceRoot":"","sources":["../../../src/services/PlatformStatsService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;gBACvC,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;OAGG;IACH,OAAO,CAAC,WAAW;IAQnB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,QAAQ,IAAI,OAAO,CAAC,sBAAsB,CAAC;CAelD"}

package/dist/src/services/PoolCacheManager.d.ts

@@ -1,258 +0,0 @@
-/**
- * Pool Cache Manager
- *
- * Manages tiered LRU caching of pool state with automatic refetching.
- * Optimized for swap monitoring with delta-based updates instead of full refetches.
- *
- * Cache Tiers:
- * - Hot Cache (50 pools): Never evicted, ~infinite TTL, highest priority
- * - Warm Cache (200 pools): 30-minute TTL, automatic refresh
- * - Cold Cache (500 max total): 5-minute TTL, LRU eviction
- *
- * @packageDocumentation
- */
-import type { CompositePoolDataResult } from '../types/composite-pool.dto';
-import type { SwapEventData as SwapMonitorEvent, SwapMonitorConfig } from '../types/swap-monitor.dto';
-import type { Logger } from '../utils/Logger';
-import type { MonitoringMetrics } from '../utils/MonitoringMetrics';
-import { LoggerBase } from './BaseService';
-/**
- * Manages tiered LRU pool cache for swap monitoring
- *
- * Maintains hot/warm/cold cache tiers with automatic eviction and refetching.
- * Tracks cache performance metrics and applies swap deltas efficiently.
- *
- * @internal
- */
-export declare class PoolCacheManager extends LoggerBase {
-    private readonly cache;
-    private readonly metrics;
-    private readonly config;
-    private readonly fetchPoolFn;
-    /** Configuration with defaults applied */
-    private readonly tierSizes;
-    /** TTL in milliseconds per tier */
-    private readonly tierTTLs;
-    /** Refetch thresholds */
-    private readonly refetchThresholds;
-    constructor(fetchPoolFn: (poolKey: string) => Promise<CompositePoolDataResult>, config: Required<SwapMonitorConfig>, metrics: MonitoringMetrics, logger?: Logger);
-    /**
-     * Retrieve pool data with three-tier LRU caching
-     *
-     * Implements intelligent cache hierarchy for optimal performance:
-     * - **Hot Cache** (50 pools): Never expires, highest priority (e.g., GALA/GUSDC)
-     * - **Warm Cache** (200 pools): 30-minute TTL, frequently accessed pools
-     * - **Cold Cache** (remaining): 5-minute TTL, LRU eviction
-     *
-     * **Cache Strategy**: Automatic tier assignment based on access patterns. Hot pools
-     * receive delta updates indefinitely. Warm/cold pools refetch periodically for accuracy.
-     *
-     * **Performance**: ~1ms cache hit, ~50-100ms cache miss (backend fetch)
-     *
-     * @param poolKey Pool identifier (e.g., 'GALA-GUSDC-3000')
-     * @returns Promise<CompositePoolDataResult> Complete pool state (cached or fresh)
-     * @throws Error if backend fetch fails
-     * @category Pool Cache
-     * @since 3.19.0
-     *
-     * @example Get pool with automatic caching
-     * ```typescript
-     * const poolData = await cacheManager.getPool('GALA-GUSDC-3000');
-     * console.log('Price:', poolData.pool.sqrtPriceX96);
-     * console.log('Liquidity:', poolData.pool.liquidity);
-     * // First call: ~80ms (cache miss)
-     * // Subsequent calls: ~1ms (cache hit)
-     * ```
-     */
-    getPool(poolKey: string): Promise<CompositePoolDataResult>;
-    /**
-     * Apply swap delta to cached pool state for real-time updates
-     *
-     * Updates pool state by calculating and applying swap deltas using SwapDeltaCalculator.
-     * This avoids expensive full pool refetches for every swap event, improving monitoring
-     * performance by 10-15x. Automatically triggers refetch when drift exceeds 5% or after
-     * 50 swaps to maintain accuracy.
-     *
-     * **Delta Calculation**: Simulates tick crossings, liquidity changes, and price movements
-     * based on swap parameters. Typical accuracy: 99.5%+ vs full refetch.
-     *
-     * **Performance**: 25-50ms per swap (1-3 tick crossings), vs 500ms+ for full refetch
-     *
-     * **Refetch Triggers**:
-     * - 50+ swaps processed since last refetch
-     * - Cumulative drift >= 5%
-     * - Delta calculation error
-     *
-     * @param poolKey Pool identifier (e.g., 'GALA-GUSDC-3000')
-     * @param direction Swap direction ('zeroForOne' = sell token0, 'oneForZero' = buy token0)
-     * @param amount0 Amount of token0 in swap (decimal string)
-     * @param amount1 Amount of token1 in swap (decimal string)
-     * @param swapEvent Optional full swap event for precise delta calculation
-     * @returns true if delta applied successfully, false if pool not cached or error occurred
-     * @category Pool Cache
-     * @since 3.19.0
-     *
-     * @example Apply swap delta
-     * ```typescript
-     * const success = cacheManager.updatePoolWithSwapDelta(
-     *   'GALA-GUSDC-3000',
-     *   'zeroForOne',
-     *   '1000.0',
-     *   '995.2',
-     *   swapEvent
-     * );
-     * if (success) {
-     *   console.log('Pool state updated via delta');
-     * }
-     * ```
-     */
-    updatePoolWithSwapDelta(poolKey: string, direction: 'zeroForOne' | 'oneForZero', amount0: string, amount1: string, swapEvent?: SwapMonitorEvent): boolean;
-    /**
-     * Get comprehensive cache statistics with tier breakdown
-     *
-     * Returns detailed metrics about cache utilization, tier distribution, and memory usage.
-     * Useful for monitoring cache effectiveness, capacity planning, and performance tuning.
-     *
-     * @returns Cache statistics object with tier sizes and memory usage
-     * @category Monitoring
-     * @since 3.19.0
-     *
-     * @example Monitor cache statistics
-     * ```typescript
-     * const stats = cacheManager.getStats();
-     * console.log(`Total cached pools: ${stats.totalCached}`);
-     * console.log(`Hot: ${stats.hotCacheSize}, Warm: ${stats.warmCacheSize}, Cold: ${stats.coldCacheSize}`);
-     * console.log(`Memory used: ${stats.memoryUsedMB.toFixed(2)} MB`);
-     *
-     * // Alert if cache is underutilized
-     * if (stats.hotCacheSize < 20) {
-     *   console.warn('Hot cache underutilized - consider monitoring more pools');
-     * }
-     * ```
-     */
-    getStats(): {
-        totalCached: number;
-        hotCacheSize: number;
-        warmCacheSize: number;
-        coldCacheSize: number;
-        memoryUsedMB: number;
-    };
-    /**
-     * Get information about a cached pool
-     *
-     * @param poolKey - Pool identifier
-     * @returns Pool info or null if not cached
-     */
-    getPoolInfo(poolKey: string): {
-        poolKey: string;
-        tier: string;
-        lastAccessTime: Date;
-        expiresAt: Date;
-        swapsSinceRefetch: number;
-        cumulativeDrift: number;
-        isExpired: boolean;
-    } | null;
-    /**
-     * Preload pool into cache (eager caching)
-     *
-     * Fetches and caches pool data before it's actively needed, reducing latency for
-     * first access. Typically used at monitoring startup to preload high-priority pools
-     * (e.g., GALA/GUSDC, top volume pools).
-     *
-     * **Use Case**: Preload top 50 pools at startup to populate hot cache tier.
-     *
-     * @param poolKey Pool identifier to preload (e.g., 'GALA-GUSDC-3000')
-     * @returns Promise<boolean> true if successfully warmed, false if fetch failed
-     * @category Pool Cache
-     * @since 3.19.0
-     *
-     * @example Warm cache for high-priority pool
-     * ```typescript
-     * const success = await cacheManager.warmCache('GALA-GUSDC-3000');
-     * if (success) {
-     *   console.log('Pool preloaded - first access will be instant');
-     * }
-     * ```
-     */
-    warmCache(poolKey: string): Promise<boolean>;
-    /**
-     * Preload multiple pools into cache with concurrency control
-     *
-     * Efficiently preloads an array of pools in parallel with rate limiting to avoid
-     * overwhelming the backend. Ideal for startup warming of top pools to populate
-     * hot cache tier. Returns statistics for monitoring warming success rate.
-     *
-     * **Use Case**: At monitoring startup, preload top 50 pools by TVL or volume.
-     *
-     * **Performance**: 5 concurrent requests = ~1 second per 5 pools (200ms each)
-     *
-     * @param poolKeys Array of pool identifiers to preload
-     * @param maxConcurrent Maximum parallel fetch requests (default: 5, max recommended: 10)
-     * @returns Promise<WarmingStats> Statistics with succeeded/failed/total counts
-     * @category Pool Cache
-     * @since 3.19.0
-     *
-     * @example Warm top pools at startup
-     * ```typescript
-     * const topPools = [
-     *   'GALA-GUSDC-3000',
-     *   'anime-GALA-3000',
-     *   'GDOG-GALA-3000'
-     * ];
-     * const stats = await cacheManager.warmCacheBatch(topPools, 5);
-     * console.log(`Warmed ${stats.succeeded}/${stats.total} pools`);
-     * if (stats.failed > 0) {
-     *   console.warn(`${stats.failed} pools failed to load`);
-     * }
-     * ```
-     */
-    warmCacheBatch(poolKeys: string[], maxConcurrent?: number): Promise<{
-        succeeded: number;
-        failed: number;
-        total: number;
-    }>;
-    /**
-     * Clear entire cache
-     */
-    clear(): void;
-    /**
-     * Clear expired entries
-     */
-    clearExpired(): void;
-    /**
-     * Determine which tier a new pool should be added to
-     *
-     * @internal
-     */
-    private determineTier;
-    /**
-     * Check if pool needs refetching
-     *
-     * @internal
-     */
-    private checkRefetchNeeded;
-    /**
-     * Check if refetch thresholds are exceeded
-     *
-     * @internal
-     */
-    private shouldRefetch;
-    /**
-     * Evict least recently used entries from cold cache
-     *
-     * Only evicts from cold cache tier. Preserves hot and warm caches.
-     *
-     * @internal
-     */
-    private evictLRU;
-    /**
-     * Refresh hot and warm tier pools
-     *
-     * Called periodically by background warming to keep frequently accessed
-     * pools fresh and prevent accumulated drift from delta-only updates.
-     *
-     * @internal
-     */
-    refreshWarmAndHotTiers(): Promise<void>;
-}
-//# sourceMappingURL=PoolCacheManager.d.ts.map

package/dist/src/services/PoolCacheManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PoolCacheManager.d.ts","sourceRoot":"","sources":["../../../src/services/PoolCacheManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAE3E,OAAO,KAAK,EAAE,aAAa,IAAI,gBAAgB,EAAC,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGrG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA+B3C;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwD;IAEpF,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAIxB;IAEF,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAIvB;IAEF,yBAAyB;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAGhC;gBAGA,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,EAClE,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACnC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,MAAM;IAkBjB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA2DhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,YAAY,GAAG,YAAY,EACtC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO;IAyEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,IAAI;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;KACtB;IAkBD;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAiBrL;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAuBlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAAE,EAClB,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IA8ChE;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,YAAY,IAAI,IAAI;IAgBpB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAkBrB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAcrB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IA2BhB;;;;;;;OAOG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;CAoC9C"}

package/dist/src/services/PoolService.d.ts

@@ -1,316 +0,0 @@
-/**
- * Pool Service
- *
- * Handles all pool-related operations including pool queries,
- * token distribution, badges, and volume data.
- *
- * @category Services
- * @since 3.6.0
- */
-import type { JwtAuth } from '../auth/JwtAuth';
-import type { FetchTokenStatsResult } from '../types/engagement-stats.dto';
-import type { CheckPoolOptions, GraphDataResult, PoolData, PoolsResult, TokenBadgesResult, TokenDistributionResult, UserHolderContext, ValidateTokenResponse } from '../types/launchpad.dto';
-import type { UpdateTokenConfigOptions } from '../types/messages.dto';
-import type { FetchVolumeDataOptions, HasTokenBadgeOptions } from '../types/options.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-/**
- * Pool Service Class
- *
- * Provides methods for:
- * - Fetching and querying pools
- * - Checking pool existence
- * - Retrieving volume/graph data
- * - Getting token distribution
- * - Managing token badges
- *
- * @example
- * ```typescript
- * const poolService = new PoolService(httpClient);
- *
- * // Fetch recent pools with cursor-based pagination
- * const pools = await poolService.fetchPools({ type: 'recent', pageSize: 10 });
- *
- * // Check if pool exists
- * const exists = await poolService.checkPool({ tokenName: 'mytoken' });
- * ```
- */
-export declare class PoolService extends BaseService {
-    constructor(http: HttpClient, jwtAuth?: JwtAuth, debugMode?: boolean);
-    /**
-     * Builds filter options object for pool fetch operations
-     * Standardizes undefined checks and produces consistent filter structure
-     * @internal
-     */
-    private buildPoolFilters;
-    /**
-     * Fetches a single page of pools (internal helper)
-     * @internal
-     */
-    private fetchSinglePage;
-    /**
-     * Fetches pools with filtering and pagination
-     *
-     * Supports cursor-based pagination for efficient data retrieval.
-     *
-     * @param options Fetch options including type, search, and pagination
-     * @returns Promise<PoolsResult> Clean pool data with full pagination
-     * @since 3.6.0
-     * @updated 3.11.0 - Added auto-pagination support
-     * @updated 5.7.0 - Added hasUpcomingShows, language, recentlyStreamed filters
-     * @updated 5.10.0 - Added streamStatus filter for CCTV monitoring
-     * @updated 8.1.0 - Migrated to cursor-based pagination
-     *
-     * @example
-     * ```typescript
-     * // Single page fetch (cursor-based)
-     * const result1 = await poolService.fetchPools({ pageSize: 20 });
-     *
-     * // Fetch next page using cursor from previous result
-     * const result2 = await poolService.fetchPools({ cursor: result1.pageInfo.nextCursor, pageSize: 20 });
-     *
-     * // Filter by streaming activity (last 24 hours)
-     * const recentlyLive = await poolService.fetchPools({ recentlyStreamed: 24 });
-     *
-     * // Filter by upcoming shows
-     * const upcomingShows = await poolService.fetchPools({ hasUpcomingShows: true });
-     *
-     * // Filter by stream language
-     * const spanishStreams = await poolService.fetchPools({ language: 'es' });
-     *
-     * // Filter by stream status (for CCTV monitoring)
-     * const activeStreams = await poolService.fetchPools({ streamStatus: 'active' });
-     * ```
-     */
-    fetchPools(options?: {
-        search?: string;
-        tokenName?: string;
-        type?: 'recent' | 'popular' | 'recordings' | 'seconds_streamed';
-        hasUpcomingShows?: boolean;
-        language?: string;
-        recentlyStreamed?: number;
-        hasRecordings?: boolean;
-        streamStatus?: 'idle' | 'active' | 'disabled';
-        cursor?: string;
-        pageSize?: number;
-    }): Promise<PoolsResult>;
-    /**
-     * Fetches all available pools with automatic pagination
-     *
-     * Convenience method that fetches all available pools by automatically
-     * handling cursor-based pagination. Uses default page size to fetch all items.
-     *
-     * @param options Optional filters (type, tokenName, search, streaming filters)
-     * @returns Promise<PoolsResult> with all pools
-     * @since 3.11.0
-     * @updated 5.7.0 - Added hasUpcomingShows, language, recentlyStreamed filters
-     * @updated 5.10.0 - Added streamStatus filter for CCTV monitoring
-     * @updated 8.1.0 - Migrated to cursor-based pagination
-     *
-     * @example
-     * ```typescript
-     * // Fetch all recent pools
-     * const all = await poolService.fetchAllPools({ type: 'recent' });
-     *
-     * // Fetch all pools matching search
-     * const matching = await poolService.fetchAllPools({ search: 'dragon' });
-     *
-     * // Fetch all pools that streamed in the last 24 hours
-     * const recentlyLive = await poolService.fetchAllPools({ recentlyStreamed: 24 });
-     *
-     * // Fetch all English-language streams with upcoming shows
-     * const upcomingEnglish = await poolService.fetchAllPools({
-     *   hasUpcomingShows: true,
-     *   language: 'en'
-     * });
-     *
-     * // Fetch all currently active streams (for CCTV monitoring)
-     * const activeStreams = await poolService.fetchAllPools({ streamStatus: 'active' });
-     * ```
-     */
-    fetchAllPools(options?: {
-        search?: string;
-        tokenName?: string;
-        type?: 'recent' | 'popular' | 'recordings' | 'seconds_streamed';
-        hasUpcomingShows?: boolean;
-        language?: string;
-        recentlyStreamed?: number;
-        hasRecordings?: boolean;
-        streamStatus?: 'idle' | 'active' | 'disabled';
-    }): Promise<PoolsResult>;
-    /**
-     * Checks if a pool exists for given token name or symbol
-     *
-     * @param options Check options with token name and/or symbol
-     * @returns Promise<boolean> True if pool exists, false otherwise
-     */
-    checkPool(options: CheckPoolOptions): Promise<boolean>;
-    /**
-     * Checks if a token name is available (convenience method)
-     *
-     * @param tokenName Token name to check
-     * @returns Promise<boolean> True if available (pool doesn't exist)
-     */
-    isTokenNameAvailable(tokenName: string): Promise<boolean>;
-    /**
-     * Checks if a token symbol is available (convenience method)
-     *
-     * @param symbol Token symbol to check
-     * @returns Promise<boolean> True if available (pool doesn't exist)
-     */
-    isTokenSymbolAvailable(symbol: string): Promise<boolean>;
-    /**
-     * Fetches volume data for a token
-     *
-     * @param options Volume data options
-     * @returns Promise<GraphDataResult> Clean volume and price data points
-     */
-    fetchVolumeData(options: FetchVolumeDataOptions): Promise<GraphDataResult>;
-    /**
-     * Get token distribution showing top holders
-     *
-     * Retrieves the list of top token holders for a specific token,
-     * along with their balances and percentage of total supply.
-     *
-     * @param tokenName Token name to fetch distribution for
-     * @returns Promise resolving to token distribution data
-     */
-    fetchTokenDistribution(tokenName: string): Promise<TokenDistributionResult>;
-    /**
-     * Get a specific user's holder context for a token
-     *
-     * Retrieves holder tier, quantity, percentage, and creator status for a user
-     * on a specific token. Used for user cards in comments/chat.
-     *
-     * @param tokenName Token name to check holdings for
-     * @param userAddress User address to lookup
-     * @returns Promise resolving to user holder context data
-     */
-    fetchUserHolderContext(tokenName: string, userAddress: string): Promise<UserHolderContext>;
-    /**
-     * Gets badge achievements for a token
-     *
-     * This endpoint retrieves volume and engagement badges for a specific token.
-     * Badges indicate milestones in trading volume and community engagement.
-     *
-     * @param tokenName The name of the token to get badges for
-     * @returns Promise<TokenBadgesResult> Badge information
-     */
-    fetchTokenBadges(tokenName: string): Promise<TokenBadgesResult>;
-    /**
-     * Convenience method to check if a token has achieved a specific badge
-     *
-     * @param options Badge check options
-     * @returns Promise<boolean> Whether the token has achieved this badge
-     */
-    hasTokenBadge(options: HasTokenBadgeOptions): Promise<boolean>;
-    /**
-     * Resolves a token name to its vault address by fetching pool data
-     *
-     * This is the canonical token resolution implementation used throughout the SDK.
-     * TokenResolverService wraps this method with caching for improved performance.
-     *
-     * @param tokenName Token name to resolve
-     * @returns Promise<string | null> Vault address if found, null otherwise
-     *
-     * @example
-     * ```typescript
-     * const vaultAddress = await poolService.resolveTokenNameToVault('dragnrkti');
-     * if (vaultAddress) {
-     *   console.log('Vault:', vaultAddress);
-     * }
-     * ```
-     */
-    resolveTokenNameToVault(tokenName: string): Promise<string | null>;
-    /**
-     * Fetch full token pool data by token name
-     * Returns complete PoolData including streaming fields
-     *
-     * @param tokenName - The token name to fetch (e.g., 'anime')
-     * @returns The full PoolData object with all fields including streaming data
-     * @throws Error if token not found or request fails
-     *
-     * @example
-     * ```typescript
-     * const pool = await sdk.fetchToken('anime');
-     * console.log(pool.tokenName, pool.playbackId, pool.muxStreamStatus);
-     * ```
-     */
-    fetchToken(tokenName: string): Promise<PoolData>;
-    /**
-     * Validate if token name and/or symbol are available
-     * Useful for token creation forms to check availability before submission
-     *
-     * @param options - Object containing optional tokenName and/or symbol to validate
-     * @returns Validation result with availability flags and errors
-     *
-     * @example
-     * ```typescript
-     * const result = await sdk.validateToken({ tokenName: 'mytoken', symbol: 'MYTKN' });
-     * if (result.nameAvailable && result.symbolAvailable) {
-     *   console.log('Names are available!');
-     * } else {
-     *   console.log('Errors:', result.errors);
-     * }
-     * ```
-     */
-    validateToken(options: {
-        tokenName?: string;
-        symbol?: string;
-    }): Promise<ValidateTokenResponse>;
-    /**
-     * Fetch engagement statistics for a token
-     *
-     * Returns metrics for chat activity, comments, and overall engagement on a token.
-     * Useful for displaying engagement metrics on token detail pages.
-     *
-     * **Public endpoint** - no authentication required.
-     *
-     * @param tokenName Token name to fetch stats for
-     * @returns FetchTokenStatsResult with engagement statistics
-     * @throws ValidationError if tokenName is invalid
-     *
-     * @since 7.1.0
-     *
-     * @example
-     * ```typescript
-     * // Fetch stats for a token
-     * const result = await poolService.fetchTokenStats('anime');
-     *
-     * console.log(`Chat messages: ${result.data.chatMessageCount}`);
-     * console.log(`Comments: ${result.data.commentCount}`);
-     * console.log(`Total engagement: ${result.data.totalEngagement}`);
-     * ```
-     */
-    fetchTokenStats(tokenName: string): Promise<FetchTokenStatsResult>;
-    /**
-     * Update token configuration (chat/comments enabled status)
-     *
-     * Requires JWT authentication with owner or admin role.
-     *
-     * @param tokenName Token name to configure
-     * @param config Configuration options
-     * @returns Promise<void>
-     * @throws ValidationError if options are invalid
-     * @throws ConfigurationError if JWT is not configured
-     *
-     * @example
-     * ```typescript
-     * // Disable chat for a token
-     * await poolService.updateTokenConfig('anime', { messagesEnabled: false });
-     *
-     * // Enable comments for a token
-     * await poolService.updateTokenConfig('anime', { commentsEnabled: true });
-     *
-     * // Update both
-     * await poolService.updateTokenConfig('anime', {
-     *   messagesEnabled: true,
-     *   commentsEnabled: false
-     * });
-     * ```
-     *
-     * @since 7.0.0
-     */
-    updateTokenConfig(tokenName: string, config: UpdateTokenConfigOptions): Promise<void>;
-}
-//# sourceMappingURL=PoolService.d.ts.map

package/dist/src/services/PoolService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PoolService.d.ts","sourceRoot":"","sources":["../../../src/services/PoolService.ts"],"names":[],"mappings":"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"}