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

package/dist/utils/object-extractors.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Object and Array Extraction Patterns
+ *
+ * Utility functions for object manipulation, field extraction, and recursive traversal.
+ * Consolidates 7-8 duplicated patterns found across event extractors and transformers.
+ *
+ * @category Utilities
+ * @since 5.16.0
+ */
+/**
+ * Extract field value from object using candidate field names
+ *
+ * Loops through candidate field names in order and returns the first non-empty string value.
+ * Consolidates 11 occurrences across LiquidityEventExtractor and SwapEventExtractor.
+ *
+ * @example
+ * ```typescript
+ * const txId = extractFieldWithCandidates(obj, ['transactionId', 'txId', 'tx_id', 'hash']);
+ * ```
+ */
+export declare function extractFieldWithCandidates(obj: Record<string, unknown>, candidates: string[]): string | null;
+/**
+ * Build object with conditionally included optional fields
+ *
+ * Starts with base object and conditionally adds optional fields only if defined.
+ * Consolidates 8 occurrences of the pattern: `if (value !== undefined) obj.field = value;`
+ *
+ * @example
+ * ```typescript
+ * const event = buildWithOptionalFields(
+ *   { id: '123', amount: '100' },
+ *   { timestamp: timestampValue, token0: token0Value }
+ * );
+ * // Returns: { id: '123', amount: '100', timestamp: ..., token0: ... }
+ * ```
+ */
+export declare function buildWithOptionalFields<T extends Record<string, unknown>>(base: T, optionalFields: Record<string, unknown>): T;
+/**
+ * Extract nested "Data" object or fallback to current object
+ *
+ * Checks for nested "Data" property and uses it if it's a non-array object.
+ * Otherwise returns the original object.
+ * Consolidates 5 occurrences in event extractors.
+ *
+ * @example
+ * ```typescript
+ * const fieldsObj = extractNestedData(payload);
+ * const txId = fieldsObj['transactionId'];
+ * ```
+ */
+export declare function extractNestedData(obj: Record<string, unknown>, nestedKey?: string): Record<string, unknown>;
+/**
+ * Recursively walk object structure with visitor callback
+ *
+ * Traverses object tree depth-first, deduplicates with WeakSet,
+ * applies visitor callback to each value, and respects max depth.
+ * Consolidates 3 occurrences in event extractors for recursive payload walking.
+ *
+ * @example
+ * ```typescript
+ * const events: LiquidityEventData[] = [];
+ * walkObjectRecursive(payload, (value) => {
+ *   const event = extractLiquidityFromObject(value);
+ *   if (event) events.push(event);
+ * }, 50);
+ * ```
+ */
+export declare function walkObjectRecursive(payload: unknown, visitor: (value: unknown) => void, maxDepth?: number): void;
+/**
+ * Normalize numeric value using recognized value mapping
+ *
+ * Maps recognized values to canonical form, applies fallback for unrecognized.
+ * Consolidates 4 occurrences of fee tier normalization pattern.
+ *
+ * @example
+ * ```typescript
+ * // Fee tier normalization: 1 or 10000 -> 10000, 0.3 or 3000 -> 3000, etc.
+ * const normalized = normalizeNumericValue(fee, {
+ *   '1': 10000,
+ *   '10000': 10000,
+ *   '0.3': 3000,
+ *   '3000': 3000,
+ *   '0.05': 500,
+ *   '500': 500,
+ * });
+ * ```
+ */
+export declare function normalizeNumericValue(value: unknown, recognizedValues: Record<string | number, number>, fallback?: number): number | null;
+/**
+ * Validate that required fields are present and non-empty
+ *
+ * Checks that all specified fields exist and are non-empty strings.
+ * Consolidates 5 occurrences of strict validation pattern.
+ *
+ * @example
+ * ```typescript
+ * if (!validateRequiredFields(obj, ['id', 'name', 'address'])) {
+ *   return null; // Missing required fields
+ * }
+ * ```
+ */
+export declare function validateRequiredFields(obj: Record<string, unknown>, fields: string[]): boolean;
+/**
+ * Merge object with defaults using spread operator pattern
+ *
+ * Safely merges existing object with new properties, handling nullish values.
+ * Consolidates 50+ occurrences of the pattern: `{...(existing || {}), ...updates}`
+ *
+ * @example
+ * ```typescript
+ * const merged = mergeWithDefaults(cachedEntry, { lastUpdated: Date.now() });
+ * ```
+ */
+export declare function mergeWithDefaults<T extends Record<string, unknown>>(existing: T | null | undefined, updates: Partial<T>): T;
+//# sourceMappingURL=object-extractors.d.ts.map

package/dist/utils/object-extractors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-extractors.d.ts","sourceRoot":"","sources":["../../src/utils/object-extractors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAAE,GACnB,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvE,IAAI,EAAE,CAAC,EACP,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC,CAAC,CAQH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,SAAS,GAAE,MAAe,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACjC,QAAQ,GAAE,MAAW,GACpB,IAAI,CAqBN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EACjD,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAiBf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,MAAM,EAAE,MAAM,EAAE,GACf,OAAO,CAOT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,QAAQ,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,CAAC,CAKH"}

package/dist/utils/object-patterns.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Conditional Spread Object Building
+ *
+ * Utility functions for building objects with conditionally included fields
+ * using spread operator patterns. Consolidates duplicated patterns across services.
+ *
+ * @category Utilities
+ * @since 5.17.0
+ */
+/**
+ * Build object with conditionally spread fields
+ *
+ * Takes a base object and conditionally spreads fields only if they are defined.
+ * Uses the pattern: `{ ...baseObj, ...(field ? { field } : {}) }` to clean up code
+ * and make intent explicit.
+ *
+ * Consolidates 2 occurrences across PoolStateManager and agent-config utilities.
+ *
+ * @template T - The base object type
+ * @param baseObj - The base object to start with
+ * @param conditionalFields - Object where each value determines if that field is included
+ * @returns New object with base fields plus defined conditional fields
+ *
+ * @example
+ * ```typescript
+ * // Simple conditional field
+ * const config = conditionalSpreadBuilder(
+ *   { id: '123', name: 'test' },
+ *   { description: descriptionValue }
+ * );
+ * // If descriptionValue is defined: { id: '123', name: 'test', description: '...' }
+ * // If descriptionValue is undefined: { id: '123', name: 'test' }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple conditional fields
+ * const event = conditionalSpreadBuilder(
+ *   { id: 'evt-1', timestamp: Date.now() },
+ *   {
+ *     source: sourceValue,      // included if sourceValue is defined
+ *     metadata: metadataObj,     // included if metadataObj is defined
+ *     tags: tagsArray            // included if tagsArray is defined
+ *   }
+ * );
+ * // Returns object with only non-undefined fields from conditionalFields
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Replaces pattern:
+ * // Old: { ...baseConfig, ...(config?.option ? { option: config.option } : {}) }
+ * // New: conditionalSpreadBuilder(baseConfig, { option: config?.option })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Works with falsy values (only undefined is excluded)
+ * const obj = conditionalSpreadBuilder(
+ *   { value: 10 },
+ *   {
+ *     count: 0,              // included (0 is defined)
+ *     empty: '',             // included ('' is defined)
+ *     nullValue: null,       // included (null is defined)
+ *     undefinedValue: undefined // excluded (undefined)
+ *   }
+ * );
+ * // Returns: { value: 10, count: 0, empty: '', nullValue: null }
+ * ```
+ *
+ * @remarks
+ * - Only fields with `undefined` values are excluded
+ * - All other falsy values (0, '', null, false) ARE included
+ * - This matches the common spread pattern behavior exactly
+ * - Order preserved: base fields first, then conditional fields
+ * - Does not mutate input objects
+ *
+ * @see buildWithOptionalFields for a similar pattern that filters on non-empty strings
+ */
+export declare function conditionalSpreadBuilder<T>(baseObj: T, conditionalFields: Record<string, unknown | undefined>): T & Record<string, unknown>;
+//# sourceMappingURL=object-patterns.d.ts.map

package/dist/utils/object-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-patterns.d.ts","sourceRoot":"","sources":["../../src/utils/object-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,OAAO,EAAE,CAAC,EACV,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,GACrD,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAU7B"}

package/dist/utils/pagination-helpers.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Pagination Helpers
+ *
+ * Centralized utilities for pagination calculations and query building.
+ * Eliminates duplicate offset/page calculation patterns found across 25+ locations.
+ *
+ * @category Utilities
+ * @since 6.5.0
+ */
+/**
+ * Pagination query parameters
+ *
+ * Standardized object for pagination parameters used in API requests.
+ *
+ * @example
+ * ```typescript
+ * const query = createPaginationQuery(2, 20);
+ * // Result: { offset: 20, limit: 20 }
+ * ```
+ */
+export interface PaginationQuery {
+    /** Zero-based offset for API requests */
+    offset: number;
+    /** Maximum number of results per page */
+    limit: number;
+}
+/**
+ * Create pagination query object for API requests
+ *
+ * Constructs a standardized pagination query with offset and limit.
+ * Validates that offset and limit are within acceptable bounds.
+ *
+ * @param offset Zero-based offset for pagination
+ * @param limit Maximum results per page (default: PAGINATION_DEFAULTS.DEFAULT_LIMIT)
+ * @returns Object with offset and limit ready for API requests
+ * @throws Error if offset or limit is invalid
+ *
+ * @example Basic usage
+ * ```typescript
+ * const query = createPaginationQuery(0, 20);
+ * // Result: { offset: 0, limit: 20 }
+ *
+ * const params = { ...query, search: 'anime' };
+ * const result = await api.fetchTokens(params);
+ * ```
+ *
+ * @example With default limit
+ * ```typescript
+ * const query = createPaginationQuery(20);
+ * // Result: { offset: 20, limit: PAGINATION_DEFAULTS.DEFAULT_LIMIT }
+ * ```
+ *
+ * @example In API request
+ * ```typescript
+ * const pools = await api.fetchPools({
+ *   ...createPaginationQuery(40, 50),
+ *   search: 'GALA'
+ * });
+ * ```
+ *
+ * @since 7.0.0
+ */
+export declare function createPaginationQuery(offset: number, limit?: number): PaginationQuery;
+/**
+ * Validate pagination parameters
+ *
+ * Ensures offset and limit values are valid before using them in API requests.
+ * Throws descriptive errors for invalid values.
+ *
+ * @param offset Zero-based offset to validate
+ * @param limit Limit/page size to validate
+ * @param contextMessage Optional message for error context (e.g., "fetchPools")
+ * @throws Error if offset or limit is invalid with descriptive message
+ *
+ * @example Basic validation
+ * ```typescript
+ * validatePaginationParams(0, 20);
+ * // No error - both valid
+ *
+ * validatePaginationParams(-1, 20);
+ * // Throws: "Invalid offset: -1. Offset must be a non-negative integer."
+ * ```
+ *
+ * @example With context
+ * ```typescript
+ * validatePaginationParams(offset, limit, 'fetchTokens');
+ * // Throws: "fetchTokens: Invalid limit: 0. Limit must be a positive integer."
+ * ```
+ *
+ * @since 7.0.0
+ */
+export declare function validatePaginationParams(offset: number, limit: number, _contextMessage?: string): void;
+/**
+ * Normalize limit to ensure it's within valid bounds
+ *
+ * Ensures limit is between min and max bounds.
+ * Useful for enforcing server-side pagination constraints.
+ * Accepts undefined and returns minLimit.
+ *
+ * @param limit Limit to normalize (undefined returns minLimit)
+ * @param minLimit Minimum allowed limit (default: 1)
+ * @param maxLimit Maximum allowed limit (default: PAGINATION_DEFAULTS.BACKEND_MAX_PAGE_SIZE)
+ * @returns Normalized limit within bounds
+ *
+ * @example
+ * ```typescript
+ * normalizeLimit(undefined) // Returns: 1
+ * normalizeLimit(0) // Returns: 1
+ * normalizeLimit(100) // Returns: 20 (if maxLimit is 20)
+ * normalizeLimit(10) // Returns: 10 (within bounds)
+ * normalizeLimit(100, 1, 50) // Returns: 50 (custom max)
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function normalizeLimit(limit: number | undefined, minLimit?: number, maxLimit?: number): number;
+/**
+ * Calculate total pages from total count and limit
+ *
+ * Determines how many pages are needed to display all items.
+ * Useful for pagination UI and progress tracking.
+ *
+ * @param total Total number of items
+ * @param limit Items per page
+ * @returns Number of pages needed
+ * @throws Error if total or limit is invalid
+ *
+ * @example
+ * ```typescript
+ * calculateTotalPages(100, 20) // Returns: 5
+ * calculateTotalPages(105, 20) // Returns: 6 (partial page)
+ * calculateTotalPages(0, 20) // Returns: 0 (no items)
+ * calculateTotalPages(20, 20) // Returns: 1
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function calculateTotalPages(total: number, limit: number): number;
+/**
+ * Check if there are more pages available
+ *
+ * Determines if pagination should continue based on current offset/limit and total.
+ * Useful for implementing auto-pagination with safety checks.
+ *
+ * @param currentOffset Current pagination offset
+ * @param limit Items per page
+ * @param total Total number of items
+ * @returns True if more pages available, false if at or past the end
+ *
+ * @example
+ * ```typescript
+ * hasMorePages(0, 20, 100) // Returns: true (offset 0, total 100)
+ * hasMorePages(80, 20, 100) // Returns: true (offset 80, only 20 left)
+ * hasMorePages(100, 20, 100) // Returns: false (offset equals total)
+ * hasMorePages(120, 20, 100) // Returns: false (offset past total)
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function hasMorePages(currentOffset: number, limit: number, total: number): boolean;
+//# sourceMappingURL=pagination-helpers.d.ts.map

package/dist/utils/pagination-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/pagination-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;CACf;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAA0C,GAChD,eAAe,CAUjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,MAAM,GACvB,IAAI,CAQN;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,GAAE,MAAU,EACpB,QAAQ,GAAE,MAAkD,GAC3D,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAuBxE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAST"}

package/dist/utils/pagination-validation.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Pagination Options Validation Helpers
+ *
+ * Utilities to safely build pagination options without violating
+ * TypeScript's exactOptionalPropertyTypes constraint.
+ *
+ * With exactOptionalPropertyTypes: true, you cannot pass undefined for optional properties.
+ * These helpers ensure proper handling.
+ *
+ * @category Utilities
+ * @since 8.0.0
+ */
+import type { BasePaginationOptions } from '../types/common';
+/**
+ * Safely build pagination options without passing undefined
+ *
+ * This helper ensures that optional pagination fields are only included
+ * when they have actual values, complying with exactOptionalPropertyTypes.
+ *
+ * @param options - Partial pagination options (may have undefined values)
+ * @returns Clean pagination options object without undefined properties
+ *
+ * @example
+ * ```typescript
+ * const cursor = getCursorFromSomewhere() || undefined;
+ * const pageSize = getPageSize();
+ *
+ * // This would cause TS2379 error:
+ * // const options: BasePaginationOptions = { cursor, pageSize };
+ *
+ * // Use this helper instead:
+ * const options = buildSafePaginationOptions({
+ *   cursor,      // May be undefined
+ *   pageSize
+ * });
+ * // Result has no undefined values
+ * ```
+ *
+ * @since 8.0.0
+ */
+export declare function buildSafePaginationOptions(options: Partial<BasePaginationOptions>): BasePaginationOptions;
+/**
+ * Safely build pagination options from a base object and overrides
+ *
+ * Merges base pagination options with overrides, ensuring no undefined values
+ * are passed for optional properties.
+ *
+ * @param base - Base pagination options (may be partial)
+ * @param overrides - Override values (may have undefined values)
+ * @returns Merged pagination options without undefined properties
+ *
+ * @example
+ * ```typescript
+ * const baseOptions = { pageSize: 50 };
+ * const cursor = getCursor();  // May be undefined
+ *
+ * // Merge safely without risk of TS2379 error
+ * const merged = mergeSafePaginationOptions(baseOptions, { cursor });
+ * // Result: { pageSize: 50, cursor: 'abc123' } (if cursor defined)
+ * // Result: { pageSize: 50 } (if cursor undefined)
+ * ```
+ *
+ * @since 8.0.0
+ */
+export declare function mergeSafePaginationOptions(base: Partial<BasePaginationOptions>, overrides: Partial<BasePaginationOptions>): BasePaginationOptions;
+/**
+ * Conditionally include a cursor in pagination options
+ *
+ * Useful for the common pattern of optionally including cursor-based pagination.
+ *
+ * @param baseOptions - Base pagination options
+ * @param cursor - Cursor token (may be undefined)
+ * @returns Options with cursor only if cursor is defined
+ *
+ * @example
+ * ```typescript
+ * const nextPageOptions = addCursorToPagination(
+ *   { pageSize: 50 },
+ *   pageInfo.nextCursor
+ * );
+ * // Result: { pageSize: 50, cursor: 'abc123' } or { pageSize: 50 }
+ * // depending on whether nextCursor is defined
+ * ```
+ *
+ * @since 8.0.0
+ */
+export declare function addCursorToPagination(baseOptions: BasePaginationOptions, cursor: string | undefined): BasePaginationOptions;
+//# sourceMappingURL=pagination-validation.d.ts.map

package/dist/utils/pagination-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination-validation.d.ts","sourceRoot":"","sources":["../../src/utils/pagination-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACtC,qBAAqB,CAcvB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,OAAO,CAAC,qBAAqB,CAAC,EACpC,SAAS,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACxC,qBAAqB,CAGvB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,qBAAqB,EAClC,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,qBAAqB,CAKvB"}

package/dist/utils/pool-pair-parser.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Pool Pair Parser
+ *
+ * Utilities for parsing poolPair strings from DEX pool discovery into components
+ * and converting pipe-delimited token formats to TypeClass objects.
+ *
+ * @packageDocumentation
+ */
+import type { TokenClassKey } from '../types/common';
+/**
+ * Parse poolPair string from fetchDexPools() into token0, token1, and fee components
+ *
+ * Format: "token0/token1/fee"
+ * Example: "GALA|Unit|none|none/Token|Unit|BENE|client:5c806869e7fd0e2384461ce9/3000"
+ *
+ * Each token is in pipe-delimited format: "collection|category|type|additionalKey"
+ *
+ * @param poolPair Pool pair string from fetchDexPools() result
+ * @returns Object with token0, token1 (both in pipe-delimited format), and fee tier
+ * @throws Error if poolPair format is invalid
+ *
+ * @example
+ * ```typescript
+ * const { token0, token1, fee } = parsePoolPair(
+ *   'GALA|Unit|none|none/Token|Unit|BENE|client:123/3000'
+ * );
+ * // → { token0: 'GALA|Unit|none|none', token1: 'Token|Unit|BENE|client:123', fee: 3000 }
+ * ```
+ */
+export declare function parsePoolPair(poolPair: string): {
+    token0: string;
+    token1: string;
+    fee: number;
+};
+/**
+ * Convert pipe-delimited token string to TokenClassKey object
+ *
+ * Format: "collection|category|type|additionalKey"
+ * Example: "GALA|Unit|none|none" or "Token|Unit|BENE|client:5c806869e7fd0e2384461ce9"
+ *
+ * Delegates to parsePipeDelimitedToken() from token-parser.ts.
+ *
+ * @param pipeDelimitedToken Token string in pipe-delimited format
+ * @returns TokenClassKey object with all components
+ * @throws ValidationError if token format is invalid
+ *
+ * @example
+ * ```typescript
+ * const tokenClass = pipeDelimitedToTokenClassKey('GALA|Unit|none|none');
+ * // → { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
+ *
+ * const tokenClass2 = pipeDelimitedToTokenClassKey('Token|Unit|BENE|client:123');
+ * // → { collection: 'Token', category: 'Unit', type: 'BENE', additionalKey: 'client:123' }
+ * ```
+ */
+export declare function pipeDelimitedToTokenClassKey(pipeDelimitedToken: string): TokenClassKey;
+//# sourceMappingURL=pool-pair-parser.d.ts.map

package/dist/utils/pool-pair-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-pair-parser.d.ts","sourceRoot":"","sources":["../../src/utils/pool-pair-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAOrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CA4CA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAAC,kBAAkB,EAAE,MAAM,GAAG,aAAa,CAatF"}