@gala-chain/launchpad-sdk 3.31.2 → 4.0.1-beta.0

package/dist/{utils → src/utils}/auto-pagination.d.ts

@@ -74,6 +74,80 @@ export interface AutoPaginationResult<T> {
  * @since 3.32.0
  */
 export declare function autoPaginate<T>(fetchFn: (page: number, limit: number) => Promise<PaginatedResult<T>>, options?: AutoPaginationOptions): Promise<AutoPaginationResult<T>>;
+/**
+ * Result object from bookmark-based API calls
+ * Returned by fetchFn in autoPaginateWithBookmark
+ */
+export interface BookmarkPaginationResult<T> {
+    /** Array of items returned from this page */
+    items: T[];
+    /** Bookmark/cursor for fetching the next page
+     *  - undefined: field was not present in API response
+     *  - empty string "": API signals last page reached
+     *  - non-empty string: bookmark to use for next request
+     */
+    nextBookmark: string | undefined;
+}
+/**
+ * Options for bookmark-based auto-pagination
+ * Used for APIs that use cursor-based pagination (bookmarks) instead of page numbers
+ */
+export interface AutoPaginationWithBookmarkOptions {
+    /** Maximum number of pages to fetch (safety limit to prevent infinite loops) */
+    maxPages?: number;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Page size to use for each request */
+    pageSize?: number;
+}
+/**
+ * Bookmark-based auto-pagination handler
+ *
+ * Automatically iterates through all pages of bookmark-based paginated API results
+ * (cursor-based pagination) and combines them into a single array.
+ *
+ * Used for APIs that return bookmarks/cursors instead of page numbers (e.g., GSwap positions API).
+ * Handles common patterns like:
+ * - Safety limits to prevent infinite loops
+ * - Empty result detection
+ * - Debug logging of pagination progress
+ * - Proper bookmark extraction from API responses
+ * - Dual completion detection (no nextBookmark OR fewer items than requested)
+ *
+ * @typeParam T - Type of items being paginated
+ * @param fetchFn Function that fetches a single page and returns items with optional nextBookmark.
+ *                Should return { items: T[], nextBookmark?: string }.
+ *                If bookmark is undefined, fetches first page.
+ * @param options Pagination options (maxPages, logger, pageSize)
+ * @returns Promise<AutoPaginationResult> All items combined from all pages
+ *
+ * @example Basic usage with bookmark-returning API
+ * ```typescript
+ * const result = await autoPaginateWithBookmark(
+ *   async (bookmark, pageSize) => {
+ *     const response = await api.getPositions({ bookmark, limit: pageSize });
+ *     return {
+ *       items: response.positions,
+ *       nextBookmark: response.metadata?.nextBookmark
+ *     };
+ *   },
+ *   { maxPages: 1000, pageSize: 10, logger }
+ * );
+ * console.log(`Total fetched: ${result.items.length}`);
+ * ```
+ *
+ * @example Legacy: Returns items array directly (uses item count for completion)
+ * ```typescript
+ * const result = await autoPaginateWithBookmark(
+ *   (bookmark, pageSize) => service.getPositions(walletAddress, pageSize, bookmark),
+ *   { maxPages: 1000, pageSize: 10, logger }
+ * );
+ * ```
+ *
+ * @since 3.32.0
+ * @since 3.33.0 - Enhanced to support true bookmark-based pagination with BookmarkPaginationResult<T>
+ */
+export declare function autoPaginateWithBookmark<T>(fetchFn: (bookmark: string | undefined, pageSize: number) => Promise<BookmarkPaginationResult<T> | T[]>, options?: AutoPaginationWithBookmarkOptions): Promise<AutoPaginationResult<T>>;
 /**
  * Build paginated result object for returning combined auto-paginated data
  *
@@ -128,5 +202,5 @@ export declare function autoPaginate<T>(fetchFn: (page: number, limit: number) =
  *
  * @since 3.32.0 - itemsKey parameter added in 3.32.0 for response structure flexibility
  */
-export declare function buildPaginatedResult<T>(items: T[], total?: number, itemsKey?: 'items' | 'pools' | 'snapshots' | 'comments' | string): Record<string, any>;
+export declare function buildPaginatedResult<T>(items: T[], total?: number, itemsKey?: 'items' | 'pools' | 'snapshots' | 'comments' | string): Record<string, unknown>;
 //# sourceMappingURL=auto-pagination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto-pagination.d.ts","sourceRoot":"","sources":["../../../src/utils/auto-pagination.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,6CAA6C;IAC7C,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,iDAAiD;IACjD,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,wCAAwC;IACxC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACrE,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAyDlC;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,6CAA6C;IAC7C,KAAK,EAAE,CAAC,EAAE,CAAC;IACX;;;;OAIG;IACH,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,iCAAiC;IAChD,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAsB,wBAAwB,CAAC,CAAC,EAC9C,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EACvG,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAqHlC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,GAAE,MAAqB,EAC5B,QAAQ,GAAE,OAAO,GAAG,OAAO,GAAG,WAAW,GAAG,UAAU,GAAG,MAAgB,GACxE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB"}

package/dist/{utils → src/utils}/bignumber-helpers.d.ts

@@ -88,11 +88,11 @@ export declare function calculateSlippageFactor(tolerance?: number): BigNumber;
 /**
  * Convert tick to sqrt ratio for liquidity calculations
  *
- * Consolidates the pattern: `new BigNumber(Math.pow(1.0001, tick / 2))`
- * Used 8+ times in GSwapService for Uniswap V3 liquidity calculations.
+ * Re-exports tickToSqrtPrice from @gala-chain/dex for Uniswap V3 liquidity calculations.
+ * Maintained as a wrapper for backward compatibility.
  *
  * @param tick The tick value from the pool
- * @returns Sqrt ratio as BigNumber
+ * @returns Sqrt price in Q64.96 format
  *
  * @example
  * ```typescript
@@ -100,8 +100,32 @@ export declare function calculateSlippageFactor(tolerance?: number): BigNumber;
  * const upperSqrtRatio = tickToSqrtRatio(tickUpper);
  * const liquidityNeeded = calculateLiquidity(lowerSqrtRatio, upperSqrtRatio, ...);
  * ```
+ *
+ * @deprecated This is a wrapper around @gala-chain/dex's tickToSqrtPrice.
+ * Consider importing tickToSqrtPrice directly for new code.
  */
 export declare function tickToSqrtRatio(tick: number): BigNumber;
+/**
+ * Convert a price to tick (Uniswap V3 math)
+ *
+ * Calculates the tick index from a price using the Uniswap V3 formula.
+ * Formula: tick = log_1.0001(price)
+ *
+ * Converts a human-readable price (e.g., "0.95", "1.05") to its corresponding
+ * Uniswap V3 tick index. Uses logarithmic calculation directly, WITHOUT Q96
+ * scaling (Q96 is only used for on-chain sqrtPrice encoding, not for human prices).
+ *
+ * @param price The price value to convert to a tick
+ * @returns Tick index (can be negative or positive)
+ *
+ * @example
+ * ```typescript
+ * const tick = priceToTick('1.5');  // Convert price 1.5 to tick
+ * const tickFloor = Math.floor(priceToTick('0.99'));  // Round down for tickLower
+ * const tickCeil = Math.ceil(priceToTick('1.01'));   // Round up for tickUpper
+ * ```
+ */
+export declare function priceToTick(price: string | number | BigNumber): number;
 /**
  * Invert a price (calculate 1 / price)
  *
@@ -261,4 +285,56 @@ export declare function increaseByPercentage(value: string | number | BigNumber,
  * ```
  */
 export declare function decreaseByPercentage(value: string | number | BigNumber, percentage: number): BigNumber;
+/**
+ * Validates that BigNumber values are strictly positive (> 0).
+ *
+ * Throws an error if any value is zero or negative. Provides clear error messages
+ * with parameter indices for debugging.
+ *
+ * @param values The values to validate
+ * @throws Error if any value is not positive
+ *
+ * @example
+ * ```typescript
+ * requirePositive(liquidity, amountIn);  // Throws if either is <= 0
+ * requirePositive(amount);  // Single value validation
+ * ```
+ */
+export declare function requirePositive(...values: BigNumber[]): void;
+/**
+ * Validates that BigNumber values are non-negative (>= 0).
+ *
+ * Throws an error if any value is negative. Allows zero values, unlike requirePositive.
+ * Useful for optional amounts that default to zero.
+ *
+ * @param values The values to validate
+ * @throws Error if any value is negative
+ *
+ * @example
+ * ```typescript
+ * requireNonNegative(fees, collectedFees);  // Allows zero but not negative
+ * ```
+ */
+export declare function requireNonNegative(...values: BigNumber[]): void;
+/**
+ * Validates a BigNumber with a custom parameter name and optional context.
+ *
+ * Provides descriptive error messages for better debugging in specific use cases.
+ * Throws an error if value is not positive (> 0).
+ *
+ * @param value The value to validate
+ * @param paramName The parameter name for the error message
+ * @param context Optional additional context (e.g., "for swap operation")
+ * @throws Error with descriptive message if value is not positive
+ *
+ * @example
+ * ```typescript
+ * requirePositiveWithContext(amount, 'amountIn', 'for swap');
+ * // Throws: "amountIn must be positive for swap, got: 0"
+ *
+ * requirePositiveWithContext(liquidity, 'liquidity');
+ * // Throws: "liquidity must be positive, got: -1"
+ * ```
+ */
+export declare function requirePositiveWithContext(value: BigNumber, paramName: string, context?: string): void;
 //# sourceMappingURL=bignumber-helpers.d.ts.map

package/dist/src/utils/bignumber-helpers.d.ts.map

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

package/dist/src/utils/bignumber-pool-cache.d.ts

@@ -0,0 +1,169 @@
+import BigNumber from 'bignumber.js';
+/**
+ * Singleton BigNumber cache for performance optimization.
+ *
+ * Caches BigNumber instances to avoid repeated parsing of the same values.
+ * Typical savings: 2-5ms per swap operation by reusing instances.
+ *
+ * @example
+ * ```typescript
+ * // Use pre-cached constants
+ * const zero = BigNumberPoolCache.ZERO;
+ * const minLimit = BigNumberPoolCache.MIN_SQRT_RATIO;
+ *
+ * // Cache dynamic values
+ * const amount = BigNumberPoolCache.getCached('1000000');
+ * const amount2 = BigNumberPoolCache.getCached('1000000'); // Same instance!
+ *
+ * // Memory management (call periodically in long-running processes)
+ * BigNumberPoolCache.trimCache(1000); // Keep 1000 most recent entries
+ * ```
+ *
+ * @remarks
+ * Thread-safe for read operations (Map is thread-safe for reads).
+ * Cache grows unbounded unless trimCache() is called periodically.
+ *
+ * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol | Uniswap V3 TickMath}
+ */
+export declare class BigNumberPoolCache {
+    /**
+     * Internal cache storage (string key → BigNumber instance)
+     * @internal
+     */
+    private static readonly CACHE;
+    /**
+     * Pre-cached zero constant (most frequently used value)
+     * @constant
+     */
+    static readonly ZERO: BigNumber;
+    /**
+     * Pre-cached one constant (used in arithmetic operations)
+     * @constant
+     */
+    static readonly ONE: BigNumber;
+    /**
+     * Fee denominator for Uniswap V3 (1,000,000 = 1,000,000 pips)
+     * Used for fee calculations: actualFee = feeAmount / FEE_PIPS
+     * @constant
+     * @example
+     * ```typescript
+     * // Calculate 0.3% fee (3000 fee tier)
+     * const fee = new BigNumber(3000).div(BigNumberPoolCache.FEE_PIPS);
+     * // fee = 0.003 (0.3%)
+     * ```
+     */
+    static readonly FEE_PIPS: BigNumber;
+    /**
+     * Minimum sqrt price ratio (corresponds to tick -887272)
+     * Uniswap V3 boundary: sqrtPriceX96 cannot go below this value
+     * @constant
+     * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol#L10 | Uniswap V3 MIN_TICK}
+     */
+    static readonly MIN_SQRT_RATIO: BigNumber;
+    /**
+     * Maximum sqrt price ratio (corresponds to tick 887272)
+     * Uniswap V3 boundary: sqrtPriceX96 cannot exceed this value
+     * @constant
+     * @see {@link https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol#L13 | Uniswap V3 MAX_TICK}
+     */
+    static readonly MAX_SQRT_RATIO: BigNumber;
+    /**
+     * Get or create cached BigNumber instance.
+     *
+     * Returns the same instance for identical values (referential equality).
+     * Avoids redundant parsing overhead for frequently used values.
+     *
+     * @param value - Numeric value (string or number)
+     * @returns Cached BigNumber instance
+     *
+     * @example
+     * ```typescript
+     * const a = BigNumberPoolCache.getCached('1000');
+     * const b = BigNumberPoolCache.getCached('1000');
+     * console.log(a === b); // true (same instance)
+     *
+     * const c = BigNumberPoolCache.getCached(1000);
+     * console.log(a === c); // true (number coerced to string key)
+     * ```
+     *
+     * @remarks
+     * - Keys are normalized to strings via `.toString()`
+     * - Cache grows unbounded unless `trimCache()` is called
+     * - O(1) lookup complexity (Map hash table)
+     */
+    static getCached(value: string | number): BigNumber;
+    /**
+     * Clear the entire cache (removes all entries).
+     *
+     * Pre-cached constants (ZERO, ONE, etc.) remain unaffected as they
+     * are static properties, not cache entries.
+     *
+     * @example
+     * ```typescript
+     * BigNumberPoolCache.clearCache();
+     * console.log(BigNumberPoolCache.getCacheStats().size); // 0
+     *
+     * // Constants still work
+     * console.log(BigNumberPoolCache.ZERO.toString()); // "0"
+     * ```
+     *
+     * @remarks
+     * Use sparingly as it discards all cached performance benefits.
+     * Prefer `trimCache()` for periodic memory management.
+     */
+    static clearCache(): void;
+    /**
+     * Get cache statistics for monitoring and debugging.
+     *
+     * @returns Object containing cache size and entry keys
+     *
+     * @example
+     * ```typescript
+     * const stats = BigNumberPoolCache.getCacheStats();
+     * console.log(`Cache size: ${stats.size}`);
+     * console.log(`Keys: ${stats.entries.join(', ')}`);
+     * ```
+     *
+     * @remarks
+     * Useful for performance profiling and memory leak detection.
+     */
+    static getCacheStats(): {
+        size: number;
+        entries: string[];
+    };
+    /**
+     * Trim cache to maximum size (FIFO eviction strategy).
+     *
+     * Keeps the N most recently inserted entries, removes oldest entries.
+     * Designed for long-running processes (arbitrage bots, market makers).
+     *
+     * @param maxSize - Maximum cache entries to retain (default: 1000)
+     *
+     * @example
+     * ```typescript
+     * // Arbitrage bot memory management pattern
+     * let swapCount = 0;
+     * async function executeSwap(params: SwapParams) {
+     *   // ... swap logic using cached BigNumbers ...
+     *
+     *   swapCount++;
+     *   if (swapCount % 100 === 0) {
+     *     BigNumberPoolCache.trimCache(1000); // Keep 1000 hot values
+     *   }
+     * }
+     * ```
+     *
+     * @remarks
+     * - Evicts oldest entries first (Map insertion order preserved)
+     * - Recommended maxSize: 500-2000 for typical trading bots
+     * - Call after every 100-500 operations in hot loops
+     * - Does not affect pre-cached constants
+     */
+    static trimCache(maxSize?: number): void;
+}
+/**
+ * Default export for convenience
+ * @see {@link BigNumberPoolCache}
+ */
+export default BigNumberPoolCache;
+//# sourceMappingURL=bignumber-pool-cache.d.ts.map

package/dist/src/utils/bignumber-pool-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bignumber-pool-cache.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber-pool-cache.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAElE;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAoB;IAExC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,YAAoB;IAEvC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,YAA0B;IAElD;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,YAA+B;IAE7D;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,YAE5B;IAEF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUnD;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;IAIzB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE;IAO3D;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,GAAE,MAAa,GAAG,IAAI;CAU/C;AAED;;;GAGG;AACH,eAAe,kBAAkB,CAAC"}

package/dist/src/utils/bondingCurveCalculations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bondingCurveCalculations.d.ts","sourceRoot":"","sources":["../../../src/utils/bondingCurveCalculations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGjE;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IACjC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,sBAAsB,CAC3B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IA+B1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,sBAAsB,CAC3B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAqC1B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,uBAAuB;IAuC1B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;CAIvB"}

package/dist/src/utils/cacheWarmingHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheWarmingHelpers.d.ts","sourceRoot":"","sources":["../../../src/utils/cacheWarmingHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,wEAAwE;IACxE,gCAAgC,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC5C,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CA2C/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAW/E"}

package/dist/src/utils/composite-pool-converter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Composite Pool Data Converter
+ *
+ * Converts raw GalaChain GetCompositePool API responses into properly
+ * typed objects with BigNumber conversions for offline calculations.
+ *
+ * Ported from offline-quote-example/quote-local.mjs createCompositePoolDtoFromResponse()
+ *
+ * ## Runtime Validation Strategy for Type Assertions
+ *
+ * This module uses strategic `as any` type assertions to work around dependency
+ * version conflicts between @gala-chain/api and @gala-chain/dex. To mitigate
+ * risks from type assertions, we employ the following validation strategy:
+ *
+ * ### Type Assertion Patterns Used
+ * 1. **TokenBalance Construction** (lines 78-79, 82-83)
+ *    - Assertion: `new TokenBalance(data as any)`
+ *    - Reason: SDK may have different @gala-chain/api version than @gala-chain/dex
+ *    - Runtime Validation: BigNumber.js validates numeric conversions on line 79
+ *
+ * 2. **TickData Property Assignment** (lines 67-72)
+ *    - Assertion: `(tickDataInstance as any).propertyName = value`
+ *    - Reason: TickData constructor only accepts 2 params; properties are set after
+ *    - Runtime Validation: All values are either boolean or BigNumber conversions
+ *
+ * 3. **CompositePoolDto Construction** (lines 87-91)
+ *    - Assertion: `token0Balance as any` and `token1Balance as any`
+ *    - Reason: TokenBalance versions may differ between dependencies
+ *    - Runtime Validation: BigNumber.js automatically validates during conversions
+ *
+ * ### Validation Guarantees
+ * - **Numeric Conversions**: BigNumber.js throws when parsing invalid numbers (NaN checks)
+ * - **Object Construction**: Pool, TickData, TokenBalance throw on constructor errors
+ * - **Property Access**: Type assertions limited to isolated property assignments
+ * - **API Contract**: Response structure validated via TypeScript type inference
+ *
+ * ### When This Strategy Breaks
+ * If API response structure changes or contains unexpected data types, errors
+ * will occur during BigNumber conversion or object construction with clear
+ * error messages indicating what data was invalid.
+ *
+ * @packageDocumentation
+ */
+import { CompositePoolDto } from '@gala-chain/dex';
+import type { GetCompositePoolResponse, CompositePoolDataResult } from '../types/composite-pool.dto';
+/**
+ * Convert GetCompositePool API response to CompositePoolDto
+ *
+ * Critical conversions:
+ * - All numeric string fields → BigNumber
+ * - Raw tick data → TickData instances
+ * - Raw balances → TokenBalance instances
+ *
+ * ## BigNumber Precision Strategy
+ *
+ * All numeric fields are converted to BigNumber.js for arbitrary precision arithmetic.
+ * This is critical for DeFi operations where precision loss causes calculation errors.
+ *
+ * **Key Fields Converted:**
+ * - Pool properties: sqrtPrice, grossPoolLiquidity, liquidity, feeGrowthGlobal0/1, protocolFees, maxLiquidityPerTick
+ * - Tick data: liquidityNet, liquidityGross, feeGrowthOutside0/1
+ * - Token balances: quantity field
+ *
+ * **Precision Characteristics:**
+ * - BigNumber.js maintains arbitrary precision (no floating-point errors)
+ * - Supports numbers beyond JavaScript's safe integer limit (2^53-1)
+ * - Suitable for token amounts with 18+ decimals (GALA, GUSDC, etc.)
+ * - No rounding errors in conversions between formats
+ *
+ * **Use Cases:**
+ * - Bonding curve calculations (exponential formulas)
+ * - Swap quote computations (multiplication/division intensive)
+ * - Tick-based liquidity calculations (high precision required)
+ * - Multi-step DeFi operations (error accumulation must be prevented)
+ *
+ * @param responseData Raw API response data
+ * @returns Fully typed CompositePoolDto with BigNumber conversions
+ * @throws Error if response data is invalid or missing required fields
+ *
+ * @example Offline quote calculation with BigNumber precision
+ * ```typescript
+ * const response = await axios.post(GCP_URL, getCompositePoolDto);
+ * const compositePool = createCompositePoolDtoFromResponse(response.data.Data);
+ *
+ * // All numeric values are BigNumber instances
+ * const sqrtPrice = compositePool.pool.sqrtPrice; // BigNumber - no precision loss
+ * const liquidity = compositePool.pool.liquidity; // BigNumber - preserves full precision
+ *
+ * // Safe calculations without floating-point errors
+ * const calculatedAmount = liquidity.times(sqrtPrice).dividedBy(someNumber);
+ * // Result is still BigNumber with full precision
+ * ```
+ *
+ * @example Accessing pool data safely
+ * ```typescript
+ * const pool = compositePool.pool;
+ *
+ * // All these are BigNumber instances - safe for math operations
+ * console.log(pool.sqrtPrice.toString()); // Full precision string representation
+ * console.log(pool.liquidity.toFixed(0)); // Fixed decimal format
+ * console.log(pool.feeGrowthGlobal0.multipliedBy(2)); // Precise multiplication
+ * ```
+ */
+/**
+ * RUNTIME VALIDATION NOTES:
+ * This function uses `as any` type assertions only where necessary for dependency
+ * compatibility. All type assertions are followed by runtime validation through:
+ * - BigNumber construction (throws on NaN or invalid numbers)
+ * - Object instantiation (Pool, TickData, TokenBalance throw on errors)
+ * - Numeric field assignments (guaranteed via BigNumber.js precision)
+ */
+export declare function createCompositePoolDtoFromResponse(responseData: GetCompositePoolResponse['Data']): CompositePoolDto;
+/**
+ * Wrap CompositePoolDto with additional metadata
+ *
+ * @param compositePoolDto Converted CompositePoolDto
+ * @param rawResponse Raw response data for reference
+ * @returns CompositePoolDataResult with full metadata
+ */
+export declare function wrapCompositePoolData(compositePoolDto: CompositePoolDto, _rawResponse: GetCompositePoolResponse['Data']): CompositePoolDataResult;
+//# sourceMappingURL=composite-pool-converter.d.ts.map

package/dist/src/utils/composite-pool-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-pool-converter.d.ts","sourceRoot":"","sources":["../../../src/utils/composite-pool-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAkB,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAInE,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAC7C,gBAAgB,CA8ElB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,gBAAgB,EAClC,YAAY,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAC7C,uBAAuB,CAazB"}

package/dist/src/utils/date-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/date-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC5C,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,CA2BN;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACjD,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,EAAE,CAER;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,GAC3C,OAAO,CAiBT;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC5C,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,CAiCN"}

package/dist/src/utils/error-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-factories.d.ts","sourceRoot":"","sources":["../../../src/utils/error-factories.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,UAAU,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,KAAK,GACpB,YAAY,CAEd;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,kBAAkB,CAEpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,gBAAgB,CAElB"}

package/dist/src/utils/error-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/error-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAOvE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAQ1E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAetD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAehE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAMxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAoBA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE;QACT,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,OAAO,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAOA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMpE"}

package/dist/{utils → src/utils}/errors.d.ts

@@ -389,4 +389,90 @@ export declare class GSwapPositionError extends Error {
      */
     constructor(message: string, originalError: unknown, code?: string | undefined);
 }
+/**
+ * Error thrown when DEX quote operations fail
+ *
+ * This error is thrown during DEX quote calculations (local and external),
+ * composite pool data fetching, and related operations. It captures the
+ * operation context for debugging and recovery.
+ *
+ * @example Quote calculation failure
+ * ```typescript
+ * throw new DexQuoteError(
+ *   'Failed to calculate quote for GALA/BENE swap',
+ *   {
+ *     fromToken: 'GALA|Unit|none|none',
+ *     toToken: 'Token|Unit|BENE|client:123',
+ *     amount: '1000'
+ *   }
+ * );
+ * ```
+ *
+ * @example Catching quote errors
+ * ```typescript
+ * try {
+ *   const quote = await sdk.calculateDexPoolQuoteExactAmountLocal({
+ *     compositePoolData: composite,
+ *     fromToken: 'GALA|Unit|none|none',
+ *     toToken: 'Token|Unit|BENE|client:123',
+ *     amount: '1000'
+ *   });
+ * } catch (error) {
+ *   if (error instanceof DexQuoteError) {
+ *     console.log(`Quote failed: ${error.message}`);
+ *     if (error.context) {
+ *       console.log(`Tokens: ${error.context.fromToken} → ${error.context.toToken}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class DexQuoteError extends ValidationError {
+    context?: any | undefined;
+    /**
+     * Creates a new DexQuoteError
+     *
+     * @param message - Human-readable error message describing what failed
+     * @param context - Optional context object with operation details (tokens, amounts, etc.)
+     */
+    constructor(message: string, context?: any | undefined);
+}
+/**
+ * Error thrown when a DEX pool is not found
+ *
+ * This error is thrown when attempting to access or fetch data for a DEX pool
+ * that does not exist, typically during composite pool data retrieval or pool
+ * discovery operations.
+ *
+ * @example Pool not found
+ * ```typescript
+ * throw new DexPoolNotFoundError(
+ *   'Pool not found: GALA/BENE with fee 3000'
+ * );
+ * ```
+ *
+ * @example Catching pool not found errors
+ * ```typescript
+ * try {
+ *   const composite = await sdk.fetchCompositePoolData({
+ *     token0: 'GALA|Unit|none|none',
+ *     token1: 'Token|Unit|BENE|client:123',
+ *     fee: 3000
+ *   });
+ * } catch (error) {
+ *   if (error instanceof DexPoolNotFoundError) {
+ *     console.log('Pool does not exist. Create it first with liquidity.');
+ *     // Implement pool creation or alternative routing
+ *   }
+ * }
+ * ```
+ */
+export declare class DexPoolNotFoundError extends ValidationError {
+    /**
+     * Creates a new DexPoolNotFoundError
+     *
+     * @param message - Human-readable error message describing which pool was not found
+     */
+    constructor(message: string);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/src/utils/errors.d.ts.map

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

package/dist/src/utils/http.d.ts.map

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