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

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

@@ -1,312 +0,0 @@
-/**
- * Ban Service
- *
- * Handles all user ban operations including creating/removing bans,
- * listing banned users, and active user management.
- *
- * @category Services
- * @since 5.5.0
- */
-import type { JwtAuth } from '../auth/JwtAuth';
-import type { ActiveUsersResult, BanListResult, BanStatusResult, CreateBanOptions, CreateBanResult, CreateGlobalBanOptions, CreateGlobalBanResult, GetActiveUsersOptions, GetBanStatusOptions, GetGlobalBanOptions, GlobalBanListResult, GlobalBanStatusResult, ListBansOptions, ListGlobalBansOptions, RemoveBanOptions, RemoveBanResult, RemoveGlobalBanOptions, RemoveGlobalBanResult } from '../types/ban.dto';
-import type { HttpClient } from '../utils/http';
-import { StreamTokenServiceBase } from './StreamTokenServiceBase';
-/**
- * Ban Service Class
- *
- * Provides methods for:
- * - Creating and removing per-token bans
- * - Creating and removing global user bans (platform-wide)
- * - Listing banned users (paginated)
- * - Checking ban status for specific users
- * - Getting active users (viewers and chat participants)
- *
- * Token-scoped endpoints require JWT authentication (token owner) or
- * admin API key using dual-auth pattern. Global ban endpoints require
- * admin API key or Overseer JWT authentication.
- *
- * @remarks
- * **Case Normalization**: Token names and user addresses are automatically
- * normalized to lowercase in all requests and responses for consistency.
- * For example, `tokenName: 'MyToken'` will return `tokenName: 'mytoken'`.
- *
- * **Security**: This service uses dual authentication:
- * - **JWT (Bearer token)**: Provides CSRF protection inherently via Authorization header.
- * - **Admin API key**: Intended for server-to-server communication only.
- *
- * When using JWT from browser clients, ensure tokens are stored securely
- * (e.g., in memory, not localStorage) to prevent XSS token theft.
- *
- * @example
- * ```typescript
- * const banService = new BanService(httpClient, 'admin-api-key', jwtAuth, true);
- *
- * // Ban a user on a specific token
- * await banService.createBan({
- *   tokenName: 'mytoken',
- *   userAddress: 'eth|abc123...',
- *   reason: 'Spam',
- *   durationSeconds: 86400 // 24 hours
- * });
- *
- * // Ban a user globally (from all tokens)
- * await banService.createGlobalBan({
- *   userAddress: 'eth|abc123...',
- *   reason: 'Platform violation',
- *   durationSeconds: 604800 // 7 days
- * });
- *
- * // List banned users
- * const bans = await banService.listBans({ tokenName: 'mytoken', pageSize: 20 });
- *
- * // List globally banned users
- * const globalBans = await banService.listGlobalBans({ pageSize: 20 });
- *
- * // Get active viewers
- * const viewers = await banService.getActiveUsers({
- *   tokenName: 'mytoken',
- *   type: 'viewers'
- * });
- * ```
- */
-export declare class BanService extends StreamTokenServiceBase {
-    constructor(http: HttpClient, adminApiKey?: string, jwtAuth?: JwtAuth, debugMode?: boolean, userApiKey?: string);
-    /**
-     * Create a ban for a user on a token
-     *
-     * Dual-auth endpoint - supports both Admin API key and JWT (owner) auth.
-     *
-     * @param options Ban options including tokenName, userAddress, and optional reason/duration
-     * @returns Created ban data
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * // Permanent ban
-     * await banService.createBan({
-     *   tokenName: 'mytoken',
-     *   userAddress: 'eth|abc123...',
-     *   reason: 'Spam'
-     * });
-     *
-     * // Temporary ban (24 hours)
-     * await banService.createBan({
-     *   tokenName: 'mytoken',
-     *   userAddress: 'eth|abc123...',
-     *   reason: 'Warned for inappropriate content',
-     *   durationSeconds: 86400
-     * });
-     * ```
-     */
-    createBan(options: CreateBanOptions): Promise<CreateBanResult>;
-    /**
-     * Remove a ban for a user on a token
-     *
-     * Dual-auth endpoint - supports both Admin API key and JWT (owner) auth.
-     *
-     * @param options Remove options including tokenName and userAddress
-     * @returns Removal confirmation
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     * @throws Error if ban not found (404)
-     *
-     * @example
-     * ```typescript
-     * const result = await banService.removeBan({
-     *   tokenName: 'mytoken',
-     *   userAddress: 'eth|abc123...'
-     * });
-     * console.log('Unbanned:', result.removed);
-     * ```
-     */
-    removeBan(options: RemoveBanOptions): Promise<RemoveBanResult>;
-    /**
-     * List all bans for a token
-     *
-     * Dual-auth endpoint - supports both Admin API key and JWT (owner) auth.
-     * Returns paginated results with user profile information.
-     *
-     * @param options List options including tokenName and optional cursor-based pagination
-     * @returns Paginated list of bans
-     * @throws ValidationError if token name is invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     * @updated 8.1.0 - Migrated to cursor-based pagination
-     *
-     * @example
-     * ```typescript
-     * // Get first page
-     * const page1 = await banService.listBans({ tokenName: 'mytoken', pageSize: 20 });
-     * console.log('Total bans:', page1.pageInfo.totalCount);
-     *
-     * // Get next page (cursor-based)
-     * if (page1.pageInfo.hasNextPage) {
-     *   const page2 = await banService.listBans({
-     *     tokenName: 'mytoken',
-     *     pageSize: 20,
-     *     cursor: page1.pageInfo.nextCursor
-     *   });
-     * }
-     * ```
-     */
-    listBans(options: ListBansOptions): Promise<BanListResult>;
-    /**
-     * Get ban status for a specific user on a token
-     *
-     * Dual-auth endpoint - supports both Admin API key and JWT (owner) auth.
-     *
-     * @param options Options including tokenName and userAddress
-     * @returns Ban status (banned: true/false with ban data if banned)
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * const status = await banService.getBanStatus({
-     *   tokenName: 'mytoken',
-     *   userAddress: 'eth|abc123...'
-     * });
-     * if (status.banned) {
-     *   console.log('User is banned:', status.ban?.reason);
-     *   console.log('Expires:', status.ban?.expiresAt);
-     * }
-     * ```
-     */
-    getBanStatus(options: GetBanStatusOptions): Promise<BanStatusResult>;
-    /**
-     * Get active users for a token
-     *
-     * Dual-auth endpoint - supports both Admin API key and JWT (owner) auth.
-     *
-     * Returns up to 1000 users. If more users are connected, the `truncated`
-     * flag will be true.
-     *
-     * @param options Options including tokenName and optional type filter
-     * @returns Active users list with metadata
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * // Get all viewers
-     * const viewers = await banService.getActiveUsers({
-     *   tokenName: 'mytoken',
-     *   type: 'viewers'
-     * });
-     * console.log('Viewers:', viewers.total);
-     * console.log('Truncated:', viewers.truncated);
-     *
-     * // Get chat participants only
-     * const chatters = await banService.getActiveUsers({
-     *   tokenName: 'mytoken',
-     *   type: 'chat_participants'
-     * });
-     * ```
-     */
-    getActiveUsers(options: GetActiveUsersOptions): Promise<ActiveUsersResult>;
-    /**
-     * Create a global ban for a user (bans from all tokens)
-     *
-     * Admin-only endpoint - requires admin API key or Overseer JWT.
-     * Bans prevent a user from accessing any token on the platform.
-     *
-     * @param options Ban options including userAddress and optional reason/duration
-     * @returns Created ban data
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * // Permanent global ban
-     * const result = await banService.createGlobalBan({
-     *   userAddress: 'eth|abc123...',
-     *   reason: 'Platform violation'
-     * });
-     * console.log('User banned from all tokens:', result.ban.userAddress);
-     *
-     * // Temporary global ban (7 days)
-     * await banService.createGlobalBan({
-     *   userAddress: 'eth|abc123...',
-     *   reason: 'Spam across multiple tokens',
-     *   durationSeconds: 604800
-     * });
-     * ```
-     *
-     * @since 6.x.0
-     */
-    createGlobalBan(options: CreateGlobalBanOptions): Promise<CreateGlobalBanResult>;
-    /**
-     * Remove a global ban for a user
-     *
-     * Admin-only endpoint - requires admin API key or Overseer JWT.
-     *
-     * @param options Remove options including userAddress
-     * @returns Removal confirmation
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     * @throws Error if ban not found (404)
-     *
-     * @example
-     * ```typescript
-     * const result = await banService.removeGlobalBan({
-     *   userAddress: 'eth|abc123...'
-     * });
-     * console.log('Global ban removed:', result.removed);
-     * ```
-     *
-     * @since 6.x.0
-     */
-    removeGlobalBan(options: RemoveGlobalBanOptions): Promise<RemoveGlobalBanResult>;
-    /**
-     * List all global bans on the platform
-     *
-     * Admin-only endpoint - requires admin API key or Overseer JWT.
-     * Returns paginated results with user profile information.
-     *
-     * @param options List options with optional pagination and filters
-     * @returns Paginated list of globally banned users
-     * @throws ValidationError if pagination options are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * // Get first page of global bans
-     * const page1 = await banService.listGlobalBans({ pageSize: 20 });
-     * console.log('Total global bans:', page1.pageInfo.totalCount);
-     *
-     * // Search for specific banned user
-     * const results = await banService.listGlobalBans({
-     *   userAddress: 'eth|abc123...',
-     *   pageSize: 10
-     * });
-     * ```
-     *
-     * @since 6.x.0
-     */
-    listGlobalBans(options?: ListGlobalBansOptions): Promise<GlobalBanListResult>;
-    /**
-     * Get global ban status for a specific user
-     *
-     * Admin-only endpoint - requires admin API key or Overseer JWT.
-     *
-     * @param options Options including userAddress
-     * @returns Ban status (banned: true/false with ban data if banned)
-     * @throws ValidationError if parameters are invalid
-     * @throws ConfigurationError if neither admin API key nor JWT is configured
-     *
-     * @example
-     * ```typescript
-     * const status = await banService.getGlobalBan({
-     *   userAddress: 'eth|abc123...'
-     * });
-     * if (status.banned) {
-     *   console.log('User is globally banned:', status.ban?.reason);
-     *   console.log('Expires:', status.ban?.expiresAt);
-     * }
-     * ```
-     *
-     * @since 6.x.0
-     */
-    getGlobalBan(options: GetGlobalBanOptions): Promise<GlobalBanStatusResult>;
-}
-//# sourceMappingURL=BanService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"BanService.d.ts","sourceRoot":"","sources":["../../../src/services/BanService.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EASa,eAAe,EACjD,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EAAC,MAAM,kBAAkB,CAAC;AAajD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,qBAAa,UAAW,SAAQ,sBAAsB;gBAElD,IAAI,EAAE,UAAU,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,OAAO,EACjB,SAAS,GAAE,OAAe,EAC1B,UAAU,CAAC,EAAE,MAAM;IASrB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IA+BpE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAyBpE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAyBhE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC;IA6B1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAuBhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA0BtF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAuBtF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAsBnF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAsBjF"}

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

@@ -1,116 +0,0 @@
-/**
- * Base Service
- *
- * Abstract base class for all SDK services providing standardized Logger initialization
- * and common service functionality.
- *
- * @category Services
- * @since 3.23.0
- */
-import type { JwtAuth } from '../auth/JwtAuth';
-import type { HttpClient } from '../utils/http';
-import { Logger } from '../utils/Logger';
-/**
- * Abstract base class for SDK services with optional HttpClient
- *
- * Provides:
- * - Standardized logger initialization with automatic context naming
- * - Optional HttpClient access for API-based services
- * - Common initialization pattern across 18+ services
- *
- * @param http Optional HTTP client for making API requests
- * @param debugMode Enable debug logging (default: false)
- *
- * @example
- * ```typescript
- * export class MyService extends BaseService {
- *   constructor(http?: HttpClient, debugMode: boolean = false) {
- *     super(http, debugMode);
- *     // Service-specific initialization
- *   }
- *
- *   myMethod() {
- *     // Logger is automatically available as this.logger
- *     this.logger.debug('Operation started');
- *   }
- * }
- * ```
- */
-export declare abstract class BaseService {
-    protected readonly http: HttpClient;
-    protected readonly logger: Logger;
-    protected jwtAuth: JwtAuth | undefined;
-    constructor(http: HttpClient, debugMode?: boolean, jwtAuth?: JwtAuth);
-    /**
-     * Set the JWT authentication manager.
-     * Allows dynamic configuration of JWT auth after service creation.
-     *
-     * @param jwtAuth - JWT auth manager instance
-     */
-    setJwtAuth(jwtAuth: JwtAuth): void;
-    /**
-     * Get JWT authorization headers.
-     * @throws ConfigurationError if JWT auth is not configured
-     *
-     * During Jest garbage collection/cleanup, returns empty headers if JWT is not configured
-     * to prevent spurious errors during test teardown.
-     */
-    protected getJwtHeaders(): Record<string, string>;
-    /**
-     * Check if the current call is coming from user code (test) vs garbage collection
-     * Uses multiple heuristics to detect call context:
-     * - Presence of expect/jest in stack (active test execution)
-     * - Presence of 'tests/' in stack (test file execution)
-     * - If neither found, likely garbage collection during cleanup
-     * @private
-     */
-    private isCalledFromUserCode;
-    /**
-     * Validate a positive integer (for IDs)
-     *
-     * @param value - Value to validate
-     * @param fieldName - Technical field name for error details
-     * @param displayName - Human-readable name for error message
-     * @throws {ValidationError} If value is not a positive integer
-     *
-     * @example
-     * ```typescript
-     * this.validatePositiveInteger(id, 'id', 'API key ID');
-     * ```
-     */
-    protected validatePositiveInteger(value: number, fieldName: string, displayName: string): void;
-}
-/**
- * Lightweight base class for services without HttpClient
- *
- * Provides:
- * - Standardized logger initialization with automatic context naming
- * - Optional custom logger injection for advanced use cases
- * - For services that don't need HttpClient (e.g., SignatureService, WebSocketService)
- *
- * @example Basic usage (auto-created logger)
- * ```typescript
- * export class MyService extends LoggerBase {
- *   constructor(private walletProvider: WalletProvider, debugMode: boolean = false) {
- *     super(debugMode);
- *     // Service-specific initialization
- *   }
- *
- *   myMethod() {
- *     // Logger is automatically available as this.logger
- *     this.logger.debug('Operation started');
- *   }
- * }
- * ```
- *
- * @example With custom logger (for multi-service coordination)
- * ```typescript
- * const sharedLogger = new Logger({ debug: true, context: 'MyService' });
- * const service = new MyService(provider, false, sharedLogger);
- * ```
- */
-export declare abstract class LoggerBase {
-    protected readonly logger: Logger;
-    constructor(debugMode?: boolean, customLogger?: Logger);
-}
-//# sourceMappingURL=BaseService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"BaseService.d.ts","sourceRoot":"","sources":["../../../src/services/BaseService.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,WAAW;IAInB,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU;IAH/C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;gBAER,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe,EAAE,OAAO,CAAC,EAAE,OAAO;IAS9F;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAYjD;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;CAG/F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8BAAsB,UAAU;IAC9B,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEtB,SAAS,GAAE,OAAe,EAAE,YAAY,CAAC,EAAE,MAAM;CAY9D"}

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

@@ -1,133 +0,0 @@
-/**
- * Batched Cache Service Base Class
- *
- * Intermediate abstraction for caches that operate on batches of items
- * (setAll, merge) rather than individual key-value pairs. Extends
- * AbstractCacheService with common batch operation patterns.
- *
- * ## Features
- * - Batch set operations (setAll - replace all)
- * - Batch merge operations (merge - add/update without removing)
- * - Timestamp tracking for cache freshness
- * - Common normalization via normalizeTokenKey()
- *
- * ## Subclass Responsibilities
- * - Override setAll/merge if custom indexing needed (e.g., network-partitioned caches)
- * - Implement getStats() for domain-specific statistics
- * - Optionally add domain-specific lookup methods
- *
- * @category Services
- * @since 5.10.0
- * @template V - Value type stored in cache
- * @template S - Statistics type (must extend BaseCacheStats)
- */
-import type { BaseCacheStats } from './AbstractCacheService.js';
-import { AbstractCacheService } from './AbstractCacheService.js';
-/**
- * Batched cache service with common token cache operations
- *
- * Provides reusable setAll/merge operations for token-like caches.
- * Subclasses must define how to extract the key from each item.
- *
- * @template V - Value type stored in cache (must have a key field)
- * @template S - Statistics type (must extend BaseCacheStats)
- */
-export declare abstract class BatchedCacheService<V, S extends BaseCacheStats = BaseCacheStats> extends AbstractCacheService<string, V, S> {
-    /** Timestamp when cache was last populated */
-    protected lastFetchedAt: number | null;
-    constructor(debugMode?: boolean);
-    /**
-     * Normalize key for consistent cache lookups
-     *
-     * Uses the common tokenNameNormalizer for uppercase, trimmed keys.
-     *
-     * @param key - Raw key to normalize
-     * @returns Normalized key string
-     */
-    protected normalizeKey(key: string): string;
-    /**
-     * Extract the cache key from an item
-     *
-     * Subclasses must implement this to define how items are keyed.
-     * For token caches, this is typically stringifiedTokenClassKey or symbol.
-     *
-     * @param item - Item to extract key from
-     * @returns Key string for cache storage
-     */
-    protected abstract extractKey(item: V): string;
-    /**
-     * Check if cache is populated
-     *
-     * @returns True if cache has items
-     */
-    hasItems(): boolean;
-    /**
-     * Get all cached items
-     *
-     * @returns Array of cached items (empty if not cached)
-     */
-    getAllItems(): V[];
-    /**
-     * Set all items (replaces existing cache)
-     *
-     * @param items - Array of items to cache
-     */
-    setAll(items: V[]): void;
-    /**
-     * Add items to cache (merges with existing)
-     *
-     * Used for pagination - adds new items without replacing existing.
-     *
-     * @param items - Array of items to add
-     */
-    merge(items: V[]): void;
-    /**
-     * Get fetch timestamp
-     *
-     * @returns Timestamp when cache was last updated, or null if never fetched
-     */
-    getFetchTimestamp(): number | null;
-    /**
-     * Clear cache and reset timestamp
-     */
-    clear(): void;
-    /**
-     * Get item by normalized key
-     *
-     * @param key - Key to look up (will be normalized)
-     * @returns Item if found, undefined if not cached
-     */
-    getByKey(key: string): V | undefined;
-    /**
-     * Check if item exists by key
-     *
-     * @param key - Key to check (will be normalized)
-     * @returns True if item is cached
-     */
-    hasKey(key: string): boolean;
-    /**
-     * Build base statistics (helper for subclasses)
-     *
-     * Provides common stats fields that most batched caches need.
-     * Subclasses can extend this with domain-specific stats.
-     *
-     * @returns Base statistics with totalItems, isPopulated, lastFetchedAt
-     *
-     * @example Extending in subclass
-     * ```typescript
-     * public getStats(): MyCacheStats {
-     *   return {
-     *     ...this.buildBaseStats(),
-     *     tokenCount: this.cache.size, // alias
-     *     customMetric: this.calculateCustomMetric(),
-     *   };
-     * }
-     * ```
-     */
-    protected buildBaseStats(): {
-        totalItems: number;
-        isPopulated: boolean;
-        lastFetchedAt: number | null;
-    };
-}
-//# sourceMappingURL=BatchedCacheService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"BatchedCacheService.d.ts","sourceRoot":"","sources":["../../../src/services/BatchedCacheService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;GAQG;AACH,8BAAsB,mBAAmB,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,GAAG,cAAc,CAAE,SAAQ,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IAChI,8CAA8C;IAC9C,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;gBAElC,SAAS,GAAE,OAAe;IAItC;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAI3C;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM;IAE9C;;;;OAIG;IACI,QAAQ,IAAI,OAAO;IAI1B;;;;OAIG;IACI,WAAW,IAAI,CAAC,EAAE;IAIzB;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAa/B;;;;;;OAMG;IACI,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAW9B;;;;OAIG;IACI,iBAAiB,IAAI,MAAM,GAAG,IAAI;IAIzC;;OAEG;IACa,KAAK,IAAI,IAAI;IAK7B;;;;;OAKG;IACI,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAK3C;;;;;OAKG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKnC;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,cAAc,IAAI;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAOvG"}

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

@@ -1,120 +0,0 @@
-/**
- * Bridgeable Token Cache Service
- *
- * Permanent in-memory cache for bridgeable tokens fetched from DEX API.
- * Bridgeable tokens are immutable - once a token is bridgeable to a network,
- * its contract address never changes.
- *
- * ## Cache Architecture
- * - **Primary Index**: Map<network, Map<symbol, token>> - O(1) by symbol
- * - **Secondary Index**: Map<network, Map<tokenId, token>> - O(1) by tokenId
- * - **Persistence**: Entire SDK lifetime (never expires)
- * - **Memory**: ~500-800 bytes per token (plus ~50 bytes per index entry)
- *
- * ## Key Features
- * - Separate caches per network (Ethereum, Solana)
- * - Case-insensitive symbol and tokenId lookups
- * - Dual O(1) lookups: by symbol or by stringifiedTokenClassKey
- * - Tracks fetch timestamps for debugging
- * - No eviction (bridgeable tokens are permanent)
- *
- * @category Services
- * @since 3.33.0
- * @refactored 5.12.0 - Now extends NetworkKeyedCacheService for DRY compliance
- */
-import type { BridgeableNetwork, BridgeableToken } from '../bridge/types/bridgeable-token.dto.js';
-import { NetworkKeyedCacheService, type NetworkKeyedCacheStats } from './NetworkKeyedCacheService.js';
-/**
- * Cache statistics for monitoring and debugging
- */
-export interface BridgeableTokenCacheStats extends NetworkKeyedCacheStats<BridgeableNetwork> {
-    /** Total tokens across all networks (alias for totalItems) */
-    totalTokens: number;
-    /** Token count per network (alias for itemsByNetwork) */
-    tokensByNetwork: Record<BridgeableNetwork, number>;
-}
-/**
- * Bridgeable Token Cache
- *
- * High-performance permanent cache for bridgeable token data.
- * Tokens are organized by network for efficient lookups during bridge operations.
- *
- * Extends NetworkKeyedCacheService for common network-keyed cache patterns.
- *
- * @example Basic usage
- * ```typescript
- * const cache = new BridgeableTokenCache();
- *
- * // Cache tokens for Ethereum
- * cache.set('ETHEREUM', ethereumTokens);
- *
- * // Check if cached
- * if (cache.has('ETHEREUM')) {
- *   const tokens = cache.getAll('ETHEREUM');
- * }
- *
- * // Get specific token by symbol
- * const gala = cache.getBySymbol('ETHEREUM', 'GALA');
- *
- * // Get specific token by tokenId
- * const token = cache.getByTokenId('ETHEREUM', 'GALA|Unit|none|none');
- * ```
- */
-export declare class BridgeableTokenCache extends NetworkKeyedCacheService<BridgeableToken, BridgeableNetwork, BridgeableTokenCacheStats> {
-    constructor(debugMode?: boolean);
-    /**
-     * Extract the primary key from a bridgeable token (symbol)
-     *
-     * @param token - Bridgeable token
-     * @returns Token symbol as primary key
-     */
-    protected extractPrimaryKey(token: BridgeableToken): string;
-    /**
-     * Extract the secondary key from a bridgeable token (tokenId)
-     *
-     * @param token - Bridgeable token
-     * @returns stringifiedTokenClassKey as secondary key
-     */
-    protected extractSecondaryKey(token: BridgeableToken): string;
-    /**
-     * Get a specific token by symbol
-     *
-     * @param network - Network to search
-     * @param symbol - Token symbol (case-insensitive)
-     * @returns Bridgeable token or undefined if not found
-     */
-    getBySymbol(network: BridgeableNetwork, symbol: string): BridgeableToken | undefined;
-    /**
-     * Get a token by its stringified TokenClassKey (tokenId)
-     *
-     * Uses the secondary tokenId index for O(1) lookup performance.
-     *
-     * @param network - Network to search
-     * @param tokenId - Stringified TokenClassKey (e.g., "GALA|Unit|none|none")
-     * @returns Bridgeable token or undefined if not found
-     */
-    getByTokenId(network: BridgeableNetwork, tokenId: string): BridgeableToken | undefined;
-    /**
-     * Get contract address for a token on a network
-     *
-     * @param network - Network to search
-     * @param symbol - Token symbol (case-insensitive)
-     * @returns Contract address or undefined if not found
-     */
-    getContractAddress(network: BridgeableNetwork, symbol: string): string | undefined;
-    /**
-     * Check if a token is bridgeable to a network
-     *
-     * @param network - Network to check
-     * @param symbol - Token symbol (case-insensitive)
-     * @returns True if token is cached and bridgeable to network
-     */
-    isTokenBridgeable(network: BridgeableNetwork, symbol: string): boolean;
-    /**
-     * Get cache statistics
-     *
-     * @returns Cache statistics including token counts and timestamps
-     */
-    getStats(): BridgeableTokenCacheStats;
-}
-//# sourceMappingURL=BridgeableTokenCache.d.ts.map