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

package/dist/services/BaseService.d.ts

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

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

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

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

@@ -0,0 +1,120 @@
+/**
+ * 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeableTokenCache.d.ts","sourceRoot":"","sources":["../../src/services/BridgeableTokenCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAC,eAAe,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,wBAAwB,EAAE,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEtG;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,sBAAsB,CAAC,iBAAiB,CAAC;IAC1F,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,eAAe,EAAE,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;CACpD;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,oBAAqB,SAAQ,wBAAwB,CAChE,eAAe,EACf,iBAAiB,EACjB,yBAAyB,CAC1B;gBACa,SAAS,GAAE,OAAe;IAItC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM;IAI3D;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM;IAI7D;;;;;;OAMG;IACI,WAAW,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI3F;;;;;;;;OAQG;IACI,YAAY,CAAC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI7F;;;;;;OAMG;IACI,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IASzF;;;;;;OAMG;IACI,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAI7E;;;;OAIG;IACI,QAAQ,IAAI,yBAAyB;CAU7C"}

package/dist/services/BridgeableTokenService.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Bridgeable Token Service
+ *
+ * Service for fetching and caching bridgeable tokens from the DEX API.
+ * Provides methods to query which tokens can be bridged to Ethereum or Solana,
+ * and retrieves their contract addresses dynamically.
+ *
+ * ## Key Features
+ * - Dynamic token discovery (no hardcoded contract addresses)
+ * - Permanent caching (bridgeable tokens never change)
+ * - Lazy loading (fetches only when needed)
+ * - Environment-aware (STAGE vs PROD URLs determine network)
+ *
+ * ## Caching Strategy
+ * - Tokens are cached permanently after first fetch
+ * - Separate caches per network (Ethereum, Solana)
+ * - Cache persists for entire SDK lifetime
+ * - No fallback - API failure throws error
+ *
+ * @category Services
+ * @since 3.33.0
+ */
+import type { BridgeableNetwork, BridgeableToken, BridgeableTokenApiResponse, FetchBridgeableTokensOptions, FetchBridgeableTokensResult, IsTokenBridgeableOptions, IsTokenBridgeableResult } from '../bridge/types/bridgeable-token.dto.js';
+import type { TokenId } from '../types/common.js';
+import type { HttpClient } from '../utils/http.js';
+import { AbstractTokenFetchService } from './AbstractTokenFetchService.js';
+import { BridgeableTokenCache } from './BridgeableTokenCache.js';
+/**
+ * BridgeableTokenService
+ *
+ * Fetches and caches bridgeable token information from the DEX API.
+ * Provides efficient lookups for bridge operations.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const service = new BridgeableTokenService(dexApiHttp, true);
+ *
+ * // Fetch all Ethereum-bridgeable tokens
+ * const result = await service.fetchAllBridgeableTokensByNetwork('ETHEREUM');
+ * console.log(`Found ${result.tokenCount} tokens`);
+ *
+ * // Check if a specific token is bridgeable (pipe-delimited format)
+ * const isBridgeable = await service.isTokenBridgeableToNetwork({
+ *   tokenId: 'GALA|Unit|none|none',
+ *   network: 'ETHEREUM'
+ * });
+ * console.log(`GALA bridgeable to Ethereum: ${isBridgeable.isBridgeable}`);
+ *
+ * // Or use TokenClassKey object format
+ * const result = await service.isTokenBridgeableToEthereum({
+ *   collection: 'Token', category: 'Unit', type: 'GALA', additionalKey: 'none'
+ * });
+ *
+ * // Get contract address for a token
+ * const address = await service.getContractAddress('GWETH', 'ETHEREUM');
+ * console.log(`GWETH Ethereum address: ${address}`);
+ * ```
+ */
+export declare class BridgeableTokenService extends AbstractTokenFetchService<BridgeableTokenApiResponse, BridgeableToken> {
+    private readonly cache;
+    constructor(dexApiHttp: HttpClient, debugMode?: boolean);
+    /**
+     * Build API request parameters for bridgeable tokens
+     *
+     * @param context - Context containing network for the request
+     * @returns Query parameters with canBridgeTo filter
+     */
+    protected buildApiParams(context?: Record<string, unknown>): Record<string, string | number | boolean>;
+    /**
+     * Transform API response tokens to SDK format
+     *
+     * @param apiTokens - Raw API response tokens
+     * @returns Array of transformed bridgeable tokens
+     */
+    protected transformApiResponse(apiTokens: BridgeableTokenApiResponse[]): BridgeableToken[];
+    /**
+     * Fetch bridgeable tokens for a network with pagination
+     *
+     * @param options - Fetch options including network and pagination parameters
+     * @returns Promise resolving to fetch result with tokens array
+     * @throws NetworkError if API request fails
+     */
+    fetchBridgeableTokensByNetwork(options: FetchBridgeableTokensOptions): Promise<FetchBridgeableTokensResult>;
+    /**
+     * Fetch ALL bridgeable tokens for a network (auto-pagination)
+     *
+     * Returns cached data if available, otherwise fetches from API.
+     * Automatically handles pagination to retrieve all tokens.
+     *
+     * @param network - Network to fetch tokens for
+     * @returns Promise resolving to fetch result with all tokens
+     * @throws NetworkError if API request fails
+     */
+    fetchAllBridgeableTokensByNetwork(network: BridgeableNetwork): Promise<FetchBridgeableTokensResult>;
+    /**
+     * Convenience: Fetch all tokens bridgeable to Ethereum
+     *
+     * @returns Promise resolving to fetch result with Ethereum-bridgeable tokens
+     */
+    fetchAllTokensBridgeableToEthereum(): Promise<FetchBridgeableTokensResult>;
+    /**
+     * Convenience: Fetch all tokens bridgeable to Solana
+     *
+     * @returns Promise resolving to fetch result with Solana-bridgeable tokens
+     */
+    fetchAllTokensBridgeableToSolana(): Promise<FetchBridgeableTokensResult>;
+    /**
+     * Check if a token is bridgeable to a network
+     *
+     * Uses cache for efficient lookup. If network not cached, fetches first.
+     *
+     * @param options - Token identifier and target network
+     * @returns Promise resolving to bridgeability result
+     *
+     * @example
+     * ```typescript
+     * // Pipe-delimited format (REQUIRED for strings)
+     * await service.isTokenBridgeableToNetwork({
+     *   tokenId: 'GALA|Unit|none|none',
+     *   network: 'ETHEREUM'
+     * });
+     *
+     * // TokenClassKey object format
+     * await service.isTokenBridgeableToNetwork({
+     *   tokenId: { collection: 'Token', category: 'Unit', type: 'GALA', additionalKey: 'none' },
+     *   network: 'SOLANA'
+     * });
+     * ```
+     */
+    isTokenBridgeableToNetwork(options: IsTokenBridgeableOptions): Promise<IsTokenBridgeableResult>;
+    /**
+     * Convenience: Check if token is bridgeable to Ethereum
+     *
+     * @param tokenId - Token identifier (pipe-delimited string or TokenClassKey object)
+     * @returns Promise resolving to bridgeability result
+     *
+     * @example
+     * ```typescript
+     * // Pipe-delimited format
+     * await service.isTokenBridgeableToEthereum('GALA|Unit|none|none');
+     *
+     * // TokenClassKey object
+     * await service.isTokenBridgeableToEthereum({
+     *   collection: 'Token', category: 'Unit', type: 'GWETH', additionalKey: 'eth:0x...'
+     * });
+     * ```
+     */
+    isTokenBridgeableToEthereum(tokenId: TokenId): Promise<IsTokenBridgeableResult>;
+    /**
+     * Convenience: Check if token is bridgeable to Solana
+     *
+     * @param tokenId - Token identifier (pipe-delimited string or TokenClassKey object)
+     * @returns Promise resolving to bridgeability result
+     *
+     * @example
+     * ```typescript
+     * // Pipe-delimited format
+     * await service.isTokenBridgeableToSolana('GALA|Unit|none|none');
+     *
+     * // TokenClassKey object
+     * await service.isTokenBridgeableToSolana({
+     *   collection: 'Token', category: 'Unit', type: 'GSOL', additionalKey: 'sol:...'
+     * });
+     * ```
+     */
+    isTokenBridgeableToSolana(tokenId: TokenId): Promise<IsTokenBridgeableResult>;
+    /**
+     * Get token by symbol from cache (or fetch if not cached)
+     *
+     * @param symbol - Token symbol (case-insensitive)
+     * @param network - Network to search
+     * @returns Promise resolving to bridgeable token or undefined
+     */
+    getTokenBySymbol(symbol: string, network: BridgeableNetwork): Promise<BridgeableToken | undefined>;
+    /**
+     * Get token by stringified TokenClassKey (tokenId) from cache (or fetch if not cached)
+     *
+     * @param tokenId - Stringified TokenClassKey (e.g., "GALA|Unit|none|none")
+     * @param network - Network to search
+     * @returns Promise resolving to bridgeable token or undefined
+     */
+    getTokenByTokenId(tokenId: string, network: BridgeableNetwork): Promise<BridgeableToken | undefined>;
+    /**
+     * Get contract address for a token on a network
+     *
+     * @param symbol - Token symbol (case-insensitive)
+     * @param network - Target network
+     * @returns Promise resolving to contract address or undefined
+     */
+    getContractAddress(symbol: string, network: BridgeableNetwork): Promise<string | undefined>;
+    /**
+     * Get all supported token symbols for a network
+     *
+     * @param network - Network to get symbols for
+     * @returns Promise resolving to array of token symbols
+     */
+    getSupportedTokenSymbols(network: BridgeableNetwork): Promise<string[]>;
+    /**
+     * Preload bridgeable tokens for both networks
+     *
+     * Fetches and caches tokens for Ethereum and Solana in parallel.
+     * Useful for eager loading to avoid latency on first bridge operation.
+     */
+    preload(): Promise<void>;
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache statistics including token counts and timestamps
+     */
+    getCacheStats(): ReturnType<BridgeableTokenCache['getStats']>;
+    /**
+     * Clear cache for a network or all networks
+     *
+     * @param network - Optional network to clear (clears all if not provided)
+     */
+    clearCache(network?: BridgeableNetwork): void;
+}
+//# sourceMappingURL=BridgeableTokenService.d.ts.map

package/dist/services/BridgeableTokenService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeableTokenService.d.ts","sourceRoot":"","sources":["../../src/services/BridgeableTokenService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,sBAAuB,SAAQ,yBAAyB,CACnE,0BAA0B,EAC1B,eAAe,CAChB;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;gBAEjC,UAAU,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAK9D;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAM5C;;;;;OAKG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,0BAA0B,EAAE,GAAG,eAAe,EAAE;IAuD1F;;;;;;OAMG;IACG,8BAA8B,CAClC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,2BAA2B,CAAC;IAkCvC;;;;;;;;;OASG;IACG,iCAAiC,CACrC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,2BAA2B,CAAC;IAuBvC;;;;OAIG;IACG,kCAAkC,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAIhF;;;;OAIG;IACG,gCAAgC,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAI9E;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,0BAA0B,CAC9B,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC;IAmCnC;;;;;;;;;;;;;;;;OAgBG;IACG,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAIrF;;;;;;;;;;;;;;;;OAgBG;IACG,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAInF;;;;;;OAMG;IACG,gBAAgB,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAUvC;;;;;;OAMG;IACG,iBAAiB,CACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAUvC;;;;;;OAMG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAS9B;;;;;OAKG;IACG,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS7E;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;;;OAIG;IACH,aAAa,IAAI,UAAU,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;IAI7D;;;;OAIG;IACH,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI;CAG9C"}