@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/services/PlatformStatsService.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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/services/PlatformStatsService.d.ts.map

@@ -0,0 +1 @@
+{"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/services/PoolCacheManager.d.ts

@@ -0,0 +1,258 @@
+/**
+ * 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/services/PoolCacheManager.d.ts.map

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

package/dist/services/PoolService.d.ts

@@ -0,0 +1,316 @@
+/**
+ * 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/services/PoolService.d.ts.map

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