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

package/dist/services/ContentReactionService.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Content Reaction Service
+ *
+ * Handles persistent content reactions on pool messages (chat messages and comments).
+ * Unlike stream reactions (ephemeral emoji bursts), content reactions are stored
+ * and displayed as counts/previews on messages.
+ *
+ * @category Services
+ * @since 5.12.0
+ */
+import type { JwtAuth } from '../auth/JwtAuth';
+import type { AddContentReactionOptions, AddContentReactionResult, RemoveContentReactionOptions, RemoveContentReactionResult } from '../types/content-reactions.dto';
+import type { HttpClient } from '../utils/http';
+import { StreamTokenServiceBase } from './StreamTokenServiceBase';
+/**
+ * Content Reaction Service Class
+ *
+ * Provides methods for:
+ * - Adding reactions to chat messages or comments (authenticated)
+ * - Removing reactions (authenticated - reaction owner only)
+ *
+ * @example
+ * ```typescript
+ * const reactionService = new ContentReactionService(httpClient, undefined, jwtAuth);
+ *
+ * // Add a reaction to a chat message
+ * const result = await reactionService.addContentReaction({
+ *   tokenName: 'mytoken',
+ *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+ *   reactionType: 'heart'
+ * });
+ *
+ * // Remove a reaction
+ * await reactionService.removeContentReaction({
+ *   tokenName: 'mytoken',
+ *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+ *   reactionType: 'heart'
+ * });
+ * ```
+ */
+export declare class ContentReactionService extends StreamTokenServiceBase {
+    constructor(http: HttpClient, adminApiKey?: string, jwtAuth?: JwtAuth, debugMode?: boolean, userApiKey?: string);
+    /**
+     * Validate token name using content reaction constraints
+     */
+    private validateReactionTokenName;
+    /**
+     * Validate message ID format
+     */
+    private validateMessageId;
+    /**
+     * Validate reaction type
+     */
+    private validateReactionType;
+    /**
+     * Add a reaction to a pool message (chat or comment)
+     *
+     * Requires JWT or API key authentication.
+     * Adding the same reaction type again is a no-op (idempotent).
+     * Users can have multiple different reaction types on the same message.
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data and whether reaction was newly created
+     * @throws ValidationError if parameters are invalid
+     * @throws ConfigurationError if authentication is not configured
+     *
+     * @example
+     * ```typescript
+     * // Add a heart reaction
+     * const result = await reactionService.addContentReaction({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'heart'
+     * });
+     * console.log('Created:', result.created);
+     * console.log('Total reactions:', result.data.totalCount);
+     * ```
+     */
+    addContentReaction(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a pool message
+     *
+     * Requires JWT or API key authentication.
+     * Only the user who created the reaction can remove it (no admin override).
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     * @throws ValidationError if parameters are invalid
+     * @throws ConfigurationError if authentication is not configured
+     *
+     * @example
+     * ```typescript
+     * // Remove a heart reaction
+     * await reactionService.removeContentReaction({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'heart'
+     * });
+     * ```
+     */
+    removeContentReaction(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+    /**
+     * Add a reaction to a chat message
+     *
+     * Convenience wrapper for addContentReaction specifically for chat messages.
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data
+     *
+     * @example
+     * ```typescript
+     * await reactionService.addReactionToChatMessage({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'fire'
+     * });
+     * ```
+     */
+    addReactionToChatMessage(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a chat message
+     *
+     * Convenience wrapper for removeContentReaction specifically for chat messages.
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     *
+     * @example
+     * ```typescript
+     * await reactionService.removeReactionFromChatMessage({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'fire'
+     * });
+     * ```
+     */
+    removeReactionFromChatMessage(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+    /**
+     * Add a reaction to a comment
+     *
+     * Convenience wrapper for addContentReaction specifically for comments.
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Updated reaction data
+     *
+     * @example
+     * ```typescript
+     * await reactionService.addReactionToComment({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'thumbs_up'
+     * });
+     * ```
+     */
+    addReactionToComment(options: AddContentReactionOptions): Promise<AddContentReactionResult>;
+    /**
+     * Remove a reaction from a comment
+     *
+     * Convenience wrapper for removeContentReaction specifically for comments.
+     *
+     * @param options Options including tokenName, messageId, and reactionType
+     * @returns Success indicator
+     *
+     * @example
+     * ```typescript
+     * await reactionService.removeReactionFromComment({
+     *   tokenName: 'mytoken',
+     *   messageId: 'msg-1703443200000-a1b2c3d4e5f6789012345678901234ab',
+     *   reactionType: 'thumbs_up'
+     * });
+     * ```
+     */
+    removeReactionFromComment(options: RemoveContentReactionOptions): Promise<RemoveContentReactionResult>;
+}
+//# sourceMappingURL=ContentReactionService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentReactionService.d.ts","sourceRoot":"","sources":["../../src/services/ContentReactionService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,KAAK,EACV,yBAAyB,EACzB,wBAAwB,EAIT,4BAA4B,EAC3C,2BAA2B,EAAC,MAAM,gCAAgC,CAAC;AAKrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAIhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,sBAAuB,SAAQ,sBAAsB;gBAE9D,IAAI,EAAE,UAAU,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,OAAO,EACjB,SAAS,GAAE,OAAe,EAC1B,UAAU,CAAC,EAAE,MAAM;IASrB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAIjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAkC/F;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IA6BxG;;;;;;;;;;;;;;;;OAgBG;IACG,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAIrG;;;;;;;;;;;;;;;;OAgBG;IACG,6BAA6B,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAQhH;;;;;;;;;;;;;;;;OAgBG;IACG,oBAAoB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAIjG;;;;;;;;;;;;;;;;OAgBG;IACG,yBAAyB,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,2BAA2B,CAAC;CAG7G"}

package/dist/services/DexBackendClient.d.ts

@@ -0,0 +1,225 @@
+/**
+ * DEX Backend API Client
+ *
+ * HTTP client for DEX Backend API endpoints using injected HttpClient.
+ * Ensures proper authentication and error handling via interceptors.
+ * Fully typed API interactions with zero `any` types.
+ *
+ * @category Services
+ * @since 3.23.0
+ */
+import type { DexBackendTokenListResponse, DexBackendUserAssetsResponse } from '../types/galachain-api.types';
+import type { HttpClient } from '../utils/http';
+/**
+ * DEX Backend Client configuration
+ *
+ * @category Services
+ * @since 3.23.0
+ */
+export interface DexBackendClientConfig {
+    /** Base URL for DEX Backend API */
+    baseUrl: string;
+    /** Optional request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * HTTP client for DEX Backend API using injected HttpClient for proper authentication
+ *
+ * Provides typed access to DEX Backend endpoints with automatic:
+ * - Authentication via injected HttpClient interceptors
+ * - Error handling and response transformation
+ * - Pagination support (offset-to-page conversion)
+ * - Response validation and type safety
+ *
+ * @category Services
+ * @since 3.23.0
+ *
+ * @example Basic usage
+ * ```typescript
+ * const httpClient = new HttpClient(config);
+ * const dexClient = new DexBackendClient(httpClient);
+ *
+ * // Fetch user's DEX assets
+ * const assets = await dexClient.getUserAssets('eth|0x123...', 20, 0);
+ * console.log(`Found ${assets.count} tokens`);
+ * console.log(`Total portfolio value: $${assets.totalValue}`);
+ * ```
+ *
+ * @example Paginated asset fetching
+ * ```typescript
+ * // First page (20 results)
+ * const page1 = await dexClient.getUserAssets('eth|0xabc...', 20, 0);
+ *
+ * // Second page (next 20 results)
+ * const page2 = await dexClient.getUserAssets('eth|0xabc...', 20, 20);
+ *
+ * // Process all tokens
+ * const allTokens = [...page1.tokens, ...page2.tokens];
+ * ```
+ */
+export declare class DexBackendClient {
+    private http;
+    /**
+     * Creates a DEX Backend client instance
+     *
+     * @param http Configured HttpClient with authentication interceptors
+     *
+     * @example
+     * ```typescript
+     * const httpClient = new HttpClient({
+     *   baseUrl: 'https://dex-backend.galachain.com',
+     *   timeout: 30000
+     * });
+     * const dexClient = new DexBackendClient(httpClient);
+     * ```
+     */
+    constructor(http: HttpClient);
+    /**
+     * Get user assets from DEX Backend
+     *
+     * Fetches all tokens in user's wallet on the DEX with balances, metadata,
+     * and optional portfolio value. Uses offset-based pagination (converted to
+     * page-based internally for DEX Backend API compatibility).
+     *
+     * Response includes:
+     * - Token balances (quantity as string for precision)
+     * - Token metadata (symbol, name, decimals)
+     * - Verification status (if token is verified)
+     * - Image URLs (if available)
+     * - Total portfolio value (if available)
+     *
+     * Endpoint: GET /user/assets
+     *
+     * @param walletAddress User's wallet address (e.g., 'eth|0x123...')
+     * @param limit Maximum number of results per page (default: 20)
+     * @param offset Pagination offset (internally converted to page number)
+     * @returns Promise resolving to user's assets with pagination metadata
+     * @throws {ApiError} If wallet address is invalid (400)
+     * @throws {ApiError} If response format is invalid (500)
+     * @throws {ApiError} If network request fails
+     *
+     * @category DEX Operations
+     * @since 3.23.0
+     *
+     * @example Fetch first page of assets
+     * ```typescript
+     * const assets = await dexClient.getUserAssets('eth|0x123...', 20, 0);
+     *
+     * console.log(`Found ${assets.count} tokens`);
+     * assets.tokens.forEach(token => {
+     *   console.log(`${token.symbol}: ${token.balance} (${token.name})`);
+     * });
+     *
+     * if (assets.totalValue) {
+     *   console.log(`Total portfolio value: $${assets.totalValue}`);
+     * }
+     * ```
+     *
+     * @example Paginated asset fetching
+     * ```typescript
+     * const limit = 20;
+     * let offset = 0;
+     * const allTokens = [];
+     *
+     * while (true) {
+     *   const result = await dexClient.getUserAssets('eth|0xabc...', limit, offset);
+     *   allTokens.push(...result.tokens);
+     *
+     *   if (result.tokens.length < limit) break; // Last page
+     *   offset += limit;
+     * }
+     *
+     * console.log(`Total tokens: ${allTokens.length}`);
+     * ```
+     *
+     * @example Filter verified tokens only
+     * ```typescript
+     * const assets = await dexClient.getUserAssets('eth|0x456...', 50, 0);
+     * const verifiedTokens = assets.tokens.filter(t => t.verified);
+     * console.log(`Verified tokens: ${verifiedTokens.length}/${assets.count}`);
+     * ```
+     */
+    getUserAssets(walletAddress: string, limit?: number, offset?: number): Promise<DexBackendUserAssetsResponse>;
+    /**
+     * Fetch token list from DEX Backend /user/token-list endpoint
+     *
+     * This is the unified endpoint for both token discovery and user assets:
+     * - **With address**: Returns tokens user owns, ordered by quantity (highest first)
+     * - **Without address**: Returns ALL available tokens, quantity always "0"
+     *
+     * Returns rich token data including image, name, description, verification status.
+     *
+     * Endpoint: GET /user/token-list
+     *
+     * @param options Fetch options
+     * @param options.address Optional wallet address (if provided, returns user's balances)
+     * @param options.search Optional search query to filter tokens
+     * @param options.page Page number (1-based, default: 1)
+     * @param options.limit Results per page (max 20, default: 20)
+     * @returns Promise resolving to token list with rich metadata
+     * @throws {ApiError} If response format is invalid (500)
+     * @throws {ApiError} If network request fails
+     *
+     * @category DEX Operations
+     * @since 4.1.0
+     *
+     * @example Fetch all available tokens (discovery)
+     * ```typescript
+     * const result = await dexClient.fetchTokenList({ page: 1, limit: 20 });
+     * console.log(`Found ${result.count} tokens available on DEX`);
+     * result.tokens.forEach(token => {
+     *   console.log(`${token.symbol}: ${token.name} (${token.image})`);
+     * });
+     * ```
+     *
+     * @example Fetch user's tokens with balances
+     * ```typescript
+     * const result = await dexClient.fetchTokenList({
+     *   address: 'eth|0x123...',
+     *   page: 1,
+     *   limit: 20
+     * });
+     * result.tokens.forEach(token => {
+     *   console.log(`${token.symbol}: ${token.quantity} (${token.name})`);
+     * });
+     * ```
+     */
+    fetchTokenList(options?: {
+        address?: string;
+        search?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<DexBackendTokenListResponse>;
+    /**
+     * Handle errors from HttpClient or validation
+     *
+     * Converts various error types to standardized ApiError instances for
+     * consistent error handling across the SDK. Preserves status codes,
+     * error messages, and response data from HTTP errors.
+     *
+     * Error transformation priorities:
+     * 1. Already an ApiError → Return as-is
+     * 2. Axios/HTTP error → Extract status, message, data from response
+     * 3. Generic Error → Wrap with 500 status code
+     * 4. Unknown error → Convert to string with 500 status
+     *
+     * @param error Error from HttpClient, validation, or generic Error
+     * @param context Method name for better error messages (e.g., 'getUserAssets(0x123...)')
+     * @returns Standardized ApiError with context and original error data
+     *
+     * @category Error Handling
+     * @since 3.23.0
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const result = await this.http.get('/user/assets', params);
+     *   return result;
+     * } catch (error) {
+     *   throw this.handleError(error, 'getUserAssets(0x123...)');
+     * }
+     * ```
+     */
+    private handleError;
+}
+//# sourceMappingURL=DexBackendClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DexBackendClient.d.ts","sourceRoot":"","sources":["../../src/services/DexBackendClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAEV,2BAA2B,EAC3B,4BAA4B,EAAC,MAAM,8BAA8B,CAAC;AAOpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAAa;IAEzB;;;;;;;;;;;;;OAaG;gBACS,IAAI,EAAE,UAAU;IAI5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACG,aAAa,CACjB,aAAa,EAAE,MAAM,EACrB,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,GACjB,OAAO,CAAC,4BAA4B,CAAC;IA4GxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACG,cAAc,CAAC,OAAO,GAAE;QAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KACX,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAqG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,OAAO,CAAC,WAAW;CAoBpB"}

package/dist/services/DexPoolService.d.ts

@@ -0,0 +1,137 @@
+/**
+ * DEX Pool Discovery Service
+ *
+ * Service for querying and exploring GalaSwap DEX liquidity pools
+ * with pagination, filtering, sorting, and quote-based pricing enrichment.
+ *
+ * @packageDocumentation
+ */
+import type { DexPoolsResult, FetchDexPoolsOptions } from '../types/dex-pool.dto';
+import type { HttpClient } from '../utils/http';
+import { BaseService } from './BaseService';
+import type { GSwapService } from './GSwapService';
+/**
+ * Service for fetching and exploring DEX pools on GalaSwap
+ *
+ * Handles pagination, filtering, sorting, and optional quote-based pricing enrichment
+ * of liquidity pools across all graduated tokens and base tokens.
+ *
+ * @category GSwap
+ * @since 3.28.0
+ */
+export declare class DexPoolService extends BaseService {
+    /** Base URL for DEX backend API */
+    private readonly dexBackendBaseUrl;
+    /** GSwap service for quote-based pricing enrichment */
+    private gswapService;
+    /** Concurrency level for parallel pricing requests */
+    private pricingConcurrency;
+    /**
+     * Create a new DexPoolService instance
+     *
+     * @param http HttpClient for making API requests
+     * @param dexBackendBaseUrl Base URL for DEX backend API
+     * @param gswapService Optional GSwap service for pricing enrichment
+     * @param pricingConcurrency Concurrency level for parallel pricing requests (default: 5)
+     * @param debugMode Enable debug logging
+     */
+    constructor(http: HttpClient, dexBackendBaseUrl: string, gswapService?: GSwapService | undefined, pricingConcurrency?: number, debugMode?: boolean);
+    /**
+     * Set GSwap service for pricing enrichment
+     *
+     * @param service GSwap service instance
+     */
+    setGSwapService(service: GSwapService): void;
+    /**
+     * Set concurrency level for pricing requests
+     *
+     * @param concurrency Number of concurrent pricing requests
+     */
+    setPricingConcurrency(concurrency: number): void;
+    /**
+     * Enrich pools with quote-based pricing
+     *
+     * Uses parallel requests with concurrency control to price each pool's tokens
+     * against GUSDC (as stable reference) via `getSwapQuoteExactInput()`.
+     *
+     * Failed pricing requests are caught and logged - pools without prices are still
+     * included with all other metrics intact (graceful degradation).
+     *
+     * @param pools Pools to enrich with pricing
+     * @returns Promise resolving to pools with token0Price and token1Price populated
+     *
+     * @private
+     */
+    private enrichPoolsWithPricing;
+    /**
+     * Fetch DEX pools with pagination and filtering
+     *
+     * Queries the DEX backend for available liquidity pools with support for:
+     * - Pagination (page/limit, max 20 per page)
+     * - Sorting by TVL, 30-day volume, or 1-day volume
+     * - Search filtering by token symbols
+     * - Optional quote-based pricing enrichment via `withPrices` option
+     *
+     * @param options Fetch options (all optional, page-based pagination with 1-indexed pages)
+     * @returns Promise resolving to paginated pool results
+     *
+     * @throws {Error} If HTTP request fails
+     * @throws {ValidationError} If sort options are invalid
+     *
+     * @example
+     * ```typescript
+     * // Fetch top 10 pools by volume with pricing
+     * const result = await dexPoolService.fetchDexPools({
+     *   sortBy: 'volume1d',
+     *   sortOrder: 'desc',
+     *   limit: 10,
+     *   page: 1,
+     *   withPrices: true
+     * });
+     *
+     * console.log(`Found ${result.pageInfo.totalCount} total pools`);
+     * result.items.forEach(pool => {
+     *   console.log(`${pool.poolName}: ${pool.token0Price} / ${pool.token1Price}`);
+     * });
+     * ```
+     *
+     * @since 3.28.0
+     */
+    fetchDexPools(options?: FetchDexPoolsOptions): Promise<DexPoolsResult>;
+    /**
+     * Fetch ALL DEX pools with automatic pagination
+     *
+     * Convenience method that automatically handles pagination to retrieve
+     * all available DEX pools. Uses maximum page size (20) for efficiency.
+     *
+     * This is useful when you need complete pool data regardless of result size.
+     * For large result sets with pricing, note that the operation may take significant time
+     * since all pools must be priced. Consider using fetchDexPools() with explicit pagination
+     * and batching if you need to process pricing incrementally.
+     *
+     * @param options Fetch options (no pagination fields, page/limit automatically handled)
+     * @returns Promise resolving to all pools with flattened pagination
+     *
+     * @example
+     * ```typescript
+     * // Fetch all pools sorted by TVL with pricing
+     * const allPools = await dexPoolService.fetchAllDexPools({
+     *   sortBy: 'tvl',
+     *   sortOrder: 'desc',
+     *   withPrices: true  // Enable pricing for all pools
+     * });
+     *
+     * console.log(`Total pools: ${allPools.pageInfo.totalCount}`);
+     * console.log(`Priced pools: ${allPools.items.filter(p => p.token0Price).length}`);
+     *
+     * // Find top GALA pools with prices
+     * const galaPools = allPools.items
+     *   .filter(p => p.poolName.includes('GALA') && p.token0Price)
+     *   .slice(0, 10);
+     * ```
+     *
+     * @since 3.28.0
+     */
+    fetchAllDexPools(options?: Omit<FetchDexPoolsOptions, 'page' | 'limit'>): Promise<DexPoolsResult>;
+}
+//# sourceMappingURL=DexPoolService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DexPoolService.d.ts","sourceRoot":"","sources":["../../src/services/DexPoolService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAEV,cAAc,EACd,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;;GAQG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE3C,uDAAuD;IACvD,OAAO,CAAC,YAAY,CAA2B;IAE/C,sDAAsD;IACtD,OAAO,CAAC,kBAAkB,CAAa;IAEvC;;;;;;;;OAQG;gBAED,IAAI,EAAE,UAAU,EAChB,iBAAiB,EAAE,MAAM,EACzB,YAAY,GAAE,YAAY,GAAG,SAAqB,EAClD,kBAAkB,GAAE,MAAU,EAC9B,SAAS,GAAE,OAAe;IAQ5B;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;;;OAIG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKhD;;;;;;;;;;;;;OAaG;YACW,sBAAsB;IAoHpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,cAAc,CAAC;IAiFhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,gBAAgB,CACpB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,OAAO,CAAM,GACzD,OAAO,CAAC,cAAc,CAAC;CAyC3B"}