@gala-chain/launchpad-sdk 8.0.2 → 9.0.0-rc.0

package/dist/services/AbstractTokenFetchService.d.ts

@@ -1,150 +0,0 @@
-/**
- * Abstract Token Fetch Service Base Class
- *
- * Provides common patterns for services that fetch and cache token data
- * from the DEX API with pagination support.
- *
- * ## Features
- * - Paginated fetch with offset/limit
- * - Auto-pagination via autoPaginateOffset
- * - Cache integration (via subclass-provided cache)
- * - Response transformation abstraction
- * - Common error handling
- *
- * ## Subclass Responsibilities
- * - Implement `buildApiParams()` for API-specific parameters
- * - Implement `transformApiResponse()` for response transformation
- * - Implement cache-specific methods (network-keyed or simple)
- * - Provide domain-specific public API methods
- *
- * ## Key Pattern
- * This base class consolidates ~150 lines of duplicate code between
- * BridgeableTokenService and WrappableTokenService by abstracting:
- * - API request structure
- * - Pagination handling
- * - Cache warming patterns
- * - Error handling
- *
- * @category Services
- * @since 5.11.0
- * @template TApiResponse - Raw API response item type
- * @template TToken - Transformed token type for SDK use
- */
-import type { OffsetPaginationFetchResult } from '../utils/auto-pagination.js';
-import type { HttpClient } from '../utils/http.js';
-import { Logger } from '../utils/Logger.js';
-/** Maximum tokens per API request (backend limit) */
-export declare const DEFAULT_MAX_LIMIT = 1000;
-/** Default limit for paginated requests */
-export declare const DEFAULT_LIMIT = 1000;
-/**
- * Base options for paginated token fetches
- */
-export interface BaseTokenFetchOptions {
-    /** Offset for pagination (default: 0) */
-    offset?: number;
-    /** Limit per page (default: 1000, max: 1000) */
-    limit?: number;
-}
-/**
- * Base result for paginated token fetches
- */
-export interface BaseTokenFetchResult<T> {
-    /** Array of transformed tokens */
-    tokens: T[];
-    /** Timestamp when data was fetched */
-    fetchedAt: number;
-    /** Number of tokens returned */
-    tokenCount: number;
-}
-/**
- * API response wrapper type (tokens array in response)
- */
-export interface TokensApiResponse<TApiResponse> {
-    tokens: TApiResponse[];
-}
-/**
- * Abstract base class for token fetch services
- *
- * Consolidates common patterns for fetching and caching token data
- * from the DEX API. Subclasses provide API-specific parameters and
- * transformation logic.
- *
- * @template TApiResponse - Raw API response item type
- * @template TToken - Transformed token type for SDK use
- */
-export declare abstract class AbstractTokenFetchService<TApiResponse, TToken> {
-    protected readonly dexApiHttp: HttpClient;
-    protected readonly logger: Logger;
-    constructor(dexApiHttp: HttpClient, debugMode?: boolean, loggerContext?: string);
-    /**
-     * Build API request parameters
-     *
-     * Subclasses implement this to add API-specific query parameters.
-     * The context parameter allows passing request-specific data (e.g., network)
-     * to avoid race conditions with mutable instance state.
-     *
-     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
-     * @returns Record of query parameters for the API request
-     */
-    protected abstract buildApiParams(context?: Record<string, unknown>): Record<string, string | number | boolean>;
-    /**
-     * Transform API response items to SDK format
-     *
-     * Subclasses implement this to convert raw API responses to typed SDK objects.
-     *
-     * @param apiTokens - Raw API response tokens
-     * @returns Array of transformed tokens
-     */
-    protected abstract transformApiResponse(apiTokens: TApiResponse[]): TToken[];
-    /**
-     * Get the API endpoint URL
-     *
-     * @returns API endpoint path (default: /v1/tokens)
-     */
-    protected getApiEndpoint(): string;
-    /**
-     * Get the maximum limit for API requests
-     *
-     * @returns Maximum items per request
-     */
-    protected getMaxLimit(): number;
-    /**
-     * Get the default limit for API requests
-     *
-     * @returns Default items per request
-     */
-    protected getDefaultLimit(): number;
-    /**
-     * Execute a paginated API request
-     *
-     * Core method that performs the HTTP request with pagination parameters.
-     * Used by both single-page and auto-paginated fetches.
-     *
-     * @param offset - Offset for pagination
-     * @param limit - Number of items to fetch
-     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
-     * @returns Promise resolving to transformed tokens
-     * @throws ValidationError if API response structure is invalid
-     */
-    protected executePaginatedRequest(offset: number, limit: number, context?: Record<string, unknown>): Promise<OffsetPaginationFetchResult<TToken>>;
-    /**
-     * Auto-paginate through all API results
-     *
-     * Fetches all pages of results automatically.
-     * Subclasses call this from their fetchAll methods.
-     *
-     * @param context - Optional context for building parameters (e.g., { network: 'ETHEREUM' })
-     * @returns Promise resolving to all transformed tokens
-     */
-    protected autoPaginateFetch(context?: Record<string, unknown>): Promise<TToken[]>;
-    /**
-     * Handle API errors consistently
-     *
-     * @param error - Error from API call
-     * @param message - Error message prefix
-     * @throws Transformed error with proper type
-     */
-    protected handleError(error: unknown, message: string): never;
-}
-//# sourceMappingURL=AbstractTokenFetchService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"AbstractTokenFetchService.d.ts","sourceRoot":"","sources":["../../src/services/AbstractTokenFetchService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAI/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAG5C,qDAAqD;AACrD,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,2CAA2C;AAC3C,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,kCAAkC;IAClC,MAAM,EAAE,CAAC,EAAE,CAAC;IACZ,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,YAAY;IAC7C,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,8BAAsB,yBAAyB,CAAC,YAAY,EAAE,MAAM;IAIhE,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU;IAH3C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAGb,UAAU,EAAE,UAAU,EACzC,SAAS,GAAE,OAAe,EAC1B,aAAa,CAAC,EAAE,MAAM;IAQxB;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAE5C;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,MAAM,EAAE;IAE5E;;;;OAIG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM;IAIlC;;;;OAIG;IACH,SAAS,CAAC,WAAW,IAAI,MAAM;IAI/B;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;;;;;;;OAWG;cACa,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;IA+B/C;;;;;;;;OAQG;cACa,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAOvF;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAG9D"}

package/dist/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/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;cACgB,cAAc,IAAI;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAOhH"}

package/dist/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

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

@@ -1 +0,0 @@
-{"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

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

@@ -1 +0,0 @@
-{"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;AAEnD,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;IAqCnC;;;;;;;;;;;;;;;;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"}