@gala-chain/launchpad-sdk 5.0.3 → 5.0.4-beta.1

package/dist/src/utils/async-patterns.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Async/Promise Pattern Utilities
+ *
+ * Common promise handling patterns extracted to eliminate code duplication.
+ * Provides type-safe wrappers for concurrent processing, timeouts, polling,
+ * and failure recovery scenarios.
+ *
+ * @category Utilities
+ * @since 3.33.0
+ */
+/**
+ * Extract successful results from Promise.allSettled array
+ *
+ * Eliminates the boilerplate of manually filtering through Promise.allSettled
+ * results to extract only the successful ones. Particularly useful for batch
+ * operations where some failures are acceptable.
+ *
+ * @typeParam T - The type of successful results
+ * @param results - Array of PromiseSettledResult from Promise.allSettled
+ * @returns Array containing only the fulfilled values
+ *
+ * @example
+ * ```typescript
+ * // Batch fetch multiple tokens where some might fail
+ * const promises = tokenNames.map(name => sdk.fetchTokenDetails(name));
+ * const allResults = await Promise.allSettled(promises);
+ * const successfulTokens = filterPromiseSettledResults(allResults);
+ *
+ * console.log(`Fetched ${successfulTokens.length}/${tokenNames.length} tokens`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Fetch pricing for pool chunk where some API calls may fail
+ * const chunkResults = await Promise.allSettled(
+ *   currentChunk.map(pool => getSwapQuote(pool))
+ * );
+ * const pricesWithData = filterPromiseSettledResults(chunkResults);
+ * ```
+ */
+export declare function filterPromiseSettledResults<T>(results: PromiseSettledResult<T>[]): T[];
+/**
+ * Wrap a promise with timeout rejection
+ *
+ * Ensures a promise resolves within a maximum time, rejecting with a clear
+ * timeout error if the deadline is exceeded. Prevents operations from hanging
+ * indefinitely while providing meaningful error context.
+ *
+ * @typeParam T - The type of the promised value
+ * @param promise - The promise to wrap with timeout
+ * @param timeoutMs - Maximum time to wait in milliseconds
+ * @param context - Optional context string to include in error message
+ * @returns Promise that rejects with TimeoutError if time exceeded
+ * @throws TimeoutError if promise doesn't resolve within timeoutMs
+ *
+ * @example
+ * ```typescript
+ * // API call with 5 second timeout
+ * const result = await withPromiseTimeout(
+ *   sdk.fetchTokenDetails('anime'),
+ *   5000,
+ *   'token details fetch'
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Wait for transaction confirmation with timeout
+ * try {
+ *   const receipt = await withPromiseTimeout(
+ *     waitForTransactionConfirmation(txHash),
+ *     30000,
+ *     'transaction confirmation'
+ *   );
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     console.log(`${error.message}`); // "Promise timed out after 30000ms: transaction confirmation"
+ *   }
+ * }
+ * ```
+ */
+export declare function withPromiseTimeout<T>(promise: Promise<T>, timeoutMs: number, context?: string): Promise<T>;
+/**
+ * Process array of items with concurrent execution limit
+ *
+ * Executes processor function on array items while limiting concurrent
+ * executions. Useful for rate-limiting API calls, preventing connection
+ * pools from being exhausted, and managing resource consumption.
+ *
+ * @typeParam T - The type of items to process
+ * @typeParam R - The type of results
+ * @param items - Array of items to process
+ * @param processor - Async function to process each item
+ * @param concurrentLimit - Maximum number of concurrent executions
+ * @returns Promise that resolves to array of results in original order
+ * @throws If any processor call throws
+ *
+ * @example
+ * ```typescript
+ * // Fetch all token details with max 5 concurrent requests
+ * const tokenNames = ['anime', 'music', 'guild', ...];
+ * const details = await processConcurrentBatches(
+ *   tokenNames,
+ *   (name) => sdk.fetchTokenDetails(name),
+ *   5 // Max 5 concurrent requests
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Rate-limited bridge fee estimation (max 2 concurrent calls)
+ * const amounts = ['100', '500', '1000', '2000'];
+ * const fees = await processConcurrentBatches(
+ *   amounts,
+ *   (amount) => sdk.estimateBridgeFee('ETH', amount),
+ *   2 // Prevent API flooding
+ * );
+ * ```
+ */
+export declare function processConcurrentBatches<T, R>(items: T[], processor: (item: T) => Promise<R>, concurrentLimit: number): Promise<R[]>;
+/**
+ * Promise.all with fallback value for failures
+ *
+ * Executes all promises and returns array with same length as input.
+ * Failed promises are replaced with fallback value instead of rejecting.
+ * Never throws - always resolves with complete array.
+ *
+ * @typeParam T - The type of promised values
+ * @param promises - Array of promises to execute
+ * @param fallback - Value to use when promise rejects
+ * @returns Promise that resolves to array with length equal to input
+ *
+ * @example
+ * ```typescript
+ * // Fetch token balances with fallback for network errors
+ * const balances = await promiseAllWithRecovery(
+ *   tokenNames.map(name => sdk.fetchTokenBalance(name)),
+ *   '0' // Use '0' balance if fetch fails
+ * );
+ * // Always returns array with same length as tokenNames
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multi-pool pricing with graceful degradation
+ * const prices = await promiseAllWithRecovery(
+ *   pools.map(pool => fetchPoolPrice(pool)),
+ *   null // Use null price if fetch fails
+ * );
+ * // Partial failures don't prevent rendering UI
+ * ```
+ */
+export declare function promiseAllWithRecovery<T>(promises: Promise<T>[], fallback: T): Promise<T[]>;
+/**
+ * Poll function until condition is met or max attempts exceeded
+ *
+ * Repeatedly executes an async function with delays until its result
+ * satisfies a condition. Useful for waiting on eventual consistency
+ * (transaction confirmation, state changes) with bounded attempts.
+ *
+ * @typeParam T - The return type of the function
+ * @param fn - Async function to poll
+ * @param condition - Predicate to check result
+ * @param opts - Poll configuration (maxAttempts, delayMs)
+ * @returns The first result matching condition
+ * @throws TimeoutError if max attempts exceeded without matching
+ *
+ * @example
+ * ```typescript
+ * // Wait for transaction to be confirmed (max 30 attempts, 1 second intervals)
+ * const receipt = await pollUntilCondition(
+ *   () => sdk.getTransactionReceipt(txHash),
+ *   (receipt) => receipt !== null,
+ *   { maxAttempts: 30, delayMs: 1000 }
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Poll until token is indexed (max 60 checks, 500ms intervals)
+ * const tokenData = await pollUntilCondition(
+ *   () => sdk.fetchTokenDetails('newtoken'),
+ *   (data) => data !== null && data.indexed === true,
+ *   { maxAttempts: 60, delayMs: 500 }
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Poll until balance reaches target
+ * const finalBalance = await pollUntilCondition(
+ *   () => sdk.fetchTokenBalance('GALA'),
+ *   (balance) => parseFloat(balance) >= 1000,
+ *   { maxAttempts: 20, delayMs: 500 }
+ * );
+ * ```
+ */
+export declare function pollUntilCondition<T>(fn: () => Promise<T>, condition: (result: T) => boolean, opts: {
+    maxAttempts: number;
+    delayMs: number;
+}): Promise<T>;
+/**
+ * Calculate exponential backoff delay with jitter
+ *
+ * Computes delay for next retry using exponential backoff formula with
+ * random jitter. Prevents thundering herd problem where many clients
+ * retry simultaneously.
+ *
+ * Formula: baseDelay * (2 ^ attemptNumber) + random jitter
+ *
+ * @param attemptNumber - Current attempt number (1-based)
+ * @param baseDelayMs - Initial delay in milliseconds (default: 100)
+ * @param maxDelayMs - Maximum delay in milliseconds (default: 32000)
+ * @returns Milliseconds to wait before next retry
+ *
+ * @example
+ * ```typescript
+ * // Calculate backoff for retry attempts
+ * const delay1 = exponentialBackoffDelay(1); // ~100ms
+ * const delay2 = exponentialBackoffDelay(2); // ~200ms
+ * const delay3 = exponentialBackoffDelay(3); // ~400ms
+ * const delay4 = exponentialBackoffDelay(4); // ~800ms (capped at maxDelayMs)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use with polling retry loop
+ * for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+ *   try {
+ *     return await operation();
+ *   } catch (error) {
+ *     const delayMs = exponentialBackoffDelay(attempt);
+ *     console.log(`Retry after ${delayMs}ms`);
+ *     await new Promise(resolve => setTimeout(resolve, delayMs));
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom base delay for slower APIs
+ * const delay = exponentialBackoffDelay(2, 500, 60000);
+ * // 500 * (2 ^ 2) + jitter = ~2000-2500ms
+ * ```
+ */
+export declare function exponentialBackoffDelay(attemptNumber: number, baseDelayMs?: number, maxDelayMs?: number): number;
+/**
+ * TimeoutError
+ *
+ * Error thrown when an async operation exceeds its time limit.
+ * Used by withPromiseTimeout and pollUntilCondition.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await withPromiseTimeout(slowOperation(), 5000);
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     console.log('Operation took too long');
+ *   }
+ * }
+ * ```
+ */
+export declare class TimeoutError extends Error {
+    /**
+     * Creates a new TimeoutError
+     *
+     * @param message - Description of what timed out
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=async-patterns.d.ts.map

package/dist/src/utils/async-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/async-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC3C,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAAE,GACjC,CAAC,EAAE,CAUL;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,CAAC,EACjD,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,CAAC,EAAE,CAAC,CAiCd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EACtB,QAAQ,EAAE,CAAC,GACV,OAAO,CAAC,CAAC,EAAE,CAAC,CAMd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,EACjC,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,CAAC,CAAC,CAoBZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,MAAY,EACzB,UAAU,GAAE,MAAe,GAC1B,MAAM,CAcR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC;;;;OAIG;gBACS,OAAO,EAAE,MAAM;CAI5B"}

package/dist/src/utils/auto-pagination.d.ts

@@ -37,6 +37,19 @@ export interface AutoPaginationOptions {
     logger?: Logger;
     /** Page size to use for each request */
     pageSize?: number;
+    /**
+     * Number of pages to fetch concurrently (default: 1 = sequential)
+     * Set to higher values (e.g., 5) to fetch multiple pages in parallel for better performance.
+     * Useful when total pages is unknown and you want to maximize throughput.
+     * @since 5.0.4
+     */
+    concurrency?: number;
+    /**
+     * Starting page number (default: 1)
+     * Use when you need to start pagination from a specific page.
+     * @since 5.0.4
+     */
+    startPage?: number;
 }
 /**
  * Result object from auto-pagination
@@ -56,13 +69,14 @@ export interface AutoPaginationResult<T> {
  * - Empty result detection
  * - Debug logging of pagination progress
  * - Preserves total count from the API
+ * - Concurrent fetching for high-throughput scenarios (optional)
  *
  * @typeParam T - Type of items being paginated
  * @param fetchFn Function that fetches a single page of results
- * @param options Pagination options (maxPages, logger, pageSize)
+ * @param options Pagination options (maxPages, logger, pageSize, concurrency, startPage)
  * @returns Promise<AutoPaginationResult> All items and total count from the API
  *
- * @example
+ * @example Sequential pagination (default)
  * ```typescript
  * const result = await autoPaginate(
  *   (page, limit) => service.fetchPools({ page, limit }),
@@ -71,7 +85,24 @@ export interface AutoPaginationResult<T> {
  * console.log(`Total: ${result.total}, Fetched: ${result.items.length}`);
  * ```
  *
+ * @example Concurrent pagination (high throughput)
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { pageSize: 20, concurrency: 5, logger }  // Fetch 5 pages at a time
+ * );
+ * ```
+ *
+ * @example Start from specific page with limit
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { startPage: 3, maxPages: 5, pageSize: 20, concurrency: 5 }  // Pages 3-7
+ * );
+ * ```
+ *
  * @since 3.32.0
+ * @since 5.0.4 - Added concurrency and startPage options
  */
 export declare function autoPaginate<T>(fetchFn: (page: number, limit: number) => Promise<PaginatedResult<T>>, options?: AutoPaginationOptions): Promise<AutoPaginationResult<T>>;
 /**
@@ -264,4 +295,166 @@ export interface OffsetPaginationFetchResult<TItem> {
  * @since 5.0.2
  */
 export declare function autoPaginateOffset<TItem>(fetchFn: (offset: number, limit: number) => Promise<OffsetPaginationFetchResult<TItem>>, options: AutoPaginationOffsetOptions): Promise<TItem[]>;
+/**
+ * Cache interface for fetchAllWithCache helper
+ *
+ * Defines the minimal cache API required by the fetchAllWithCache utility.
+ * Allows different cache implementations (BridgeableTokenCache, WrappableTokenCache)
+ * to be used with the same helper function.
+ *
+ * @typeParam T - Type of items stored in the cache
+ * @since 5.10.0
+ */
+export interface CacheInterface<T> {
+    /** Check if cache has data */
+    has(): boolean;
+    /** Get all cached items */
+    getAll(): T[];
+    /** Get fetch timestamp (when cache was last populated) */
+    getFetchTimestamp(): number | null | undefined;
+    /** Set/replace cache with new items */
+    setAll(items: T[]): void;
+}
+/**
+ * Cache interface for network-keyed caches (like BridgeableTokenCache)
+ *
+ * Extended interface for caches that store items per-network key.
+ *
+ * @typeParam T - Type of items stored in the cache
+ * @typeParam K - Network key type (e.g., BridgeableNetwork)
+ * @since 5.10.0
+ */
+export interface NetworkCacheInterface<T, K extends string = string> {
+    /** Check if cache has data for a network */
+    has(network: K): boolean;
+    /** Get all cached items for a network */
+    getAll(network: K): T[];
+    /** Get fetch timestamp for a network */
+    getFetchTimestamp(network: K): number | null | undefined;
+    /** Set/replace cache for a network */
+    set(network: K, items: T[]): void;
+}
+/**
+ * Options for fetchAllWithCache helper
+ */
+export interface FetchAllWithCacheOptions<T> {
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Function to fetch all items (already paginated) */
+    fetchFn: () => Promise<T[]>;
+    /** Cache instance implementing CacheInterface */
+    cache: CacheInterface<T>;
+    /** Item type name for logging (e.g., 'wrappable tokens') */
+    itemTypeName?: string;
+}
+/**
+ * Options for fetchAllWithNetworkCache helper
+ */
+export interface FetchAllWithNetworkCacheOptions<T, K extends string = string> {
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Network key to fetch/cache for */
+    network: K;
+    /** Function to fetch all items for the network (already paginated) */
+    fetchFn: () => Promise<T[]>;
+    /** Cache instance implementing NetworkCacheInterface */
+    cache: NetworkCacheInterface<T, K>;
+    /** Item type name for logging (e.g., 'bridgeable tokens') */
+    itemTypeName?: string;
+}
+/**
+ * Result structure for fetchAllWithCache helpers
+ *
+ * Standard return format with items, timestamp, and count.
+ */
+export interface FetchAllWithCacheResult<T> {
+    /** All fetched or cached items */
+    items: T[];
+    /** Timestamp when data was fetched (epoch ms) */
+    fetchedAt: number;
+    /** Number of items */
+    itemCount: number;
+}
+/**
+ * Fetch all items with caching support (simple cache)
+ *
+ * Helper that eliminates the repetitive cache-check -> fetch -> cache-store pattern
+ * found in services like WrappableTokenService.fetchAllWrappableTokens().
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * if (this.cache.has()) {
+ *   const items = this.cache.getAll();
+ *   return { items, fetchedAt: this.cache.getFetchTimestamp(), itemCount: items.length };
+ * }
+ * const allItems = await autoPaginateOffset(...);
+ * this.cache.setAll(allItems);
+ * return { items: allItems, fetchedAt: Date.now(), itemCount: allItems.length };
+ * ```
+ *
+ * @typeParam T - Type of items being fetched
+ * @param options - Options including cache, fetchFn, and logger
+ * @returns Promise resolving to items with fetchedAt timestamp and count
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await fetchAllWithCache({
+ *   cache: this.cache,
+ *   fetchFn: () => autoPaginateOffset(
+ *     async (offset, limit) => ({
+ *       items: this.transformTokens(response.tokens),
+ *       rawCount: response.tokens.length,
+ *     }),
+ *     { maxLimit: MAX_LIMIT, logger: this.logger }
+ *   ),
+ *   logger: this.logger,
+ *   itemTypeName: 'wrappable tokens',
+ * });
+ * ```
+ *
+ * @since 5.10.0
+ */
+export declare function fetchAllWithCache<T>(options: FetchAllWithCacheOptions<T>): Promise<FetchAllWithCacheResult<T>>;
+/**
+ * Fetch all items with network-keyed caching support
+ *
+ * Helper that eliminates the repetitive cache-check -> fetch -> cache-store pattern
+ * found in services like BridgeableTokenService.fetchAllBridgeableTokensByNetwork().
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * if (this.cache.has(network)) {
+ *   const tokens = this.cache.getAll(network);
+ *   return { tokens, network, fetchedAt: this.cache.getFetchTimestamp(network), tokenCount: tokens.length };
+ * }
+ * const allTokens = await autoPaginateOffset(...);
+ * this.cache.set(network, allTokens);
+ * return { tokens: allTokens, network, fetchedAt: Date.now(), tokenCount: allTokens.length };
+ * ```
+ *
+ * @typeParam T - Type of items being fetched
+ * @typeParam K - Network key type (e.g., 'ETHEREUM' | 'SOLANA')
+ * @param options - Options including network, cache, fetchFn, and logger
+ * @returns Promise resolving to items with fetchedAt timestamp and count
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await fetchAllWithNetworkCache({
+ *   network: 'ETHEREUM',
+ *   cache: this.cache,
+ *   fetchFn: () => autoPaginateOffset(
+ *     async (offset, limit) => ({
+ *       items: this.transformTokens(response.tokens, network),
+ *       rawCount: response.tokens.length,
+ *     }),
+ *     { maxLimit: MAX_LIMIT, logger: this.logger }
+ *   ),
+ *   logger: this.logger,
+ *   itemTypeName: 'bridgeable tokens',
+ * });
+ * ```
+ *
+ * @since 5.10.0
+ */
+export declare function fetchAllWithNetworkCache<T, K extends string = string>(options: FetchAllWithNetworkCacheOptions<T, K>): Promise<FetchAllWithCacheResult<T>>;
 //# sourceMappingURL=auto-pagination.d.ts.map

package/dist/src/utils/auto-pagination.d.ts.map

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