@gala-chain/launchpad-sdk 3.31.0 → 4.0.0

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

@@ -0,0 +1,206 @@
+/**
+ * Auto-Pagination Utility
+ *
+ * Generic utility for automatically paginating through API results.
+ * Eliminates duplicate pagination logic across multiple services.
+ *
+ * @packageDocumentation
+ */
+import { Logger } from './Logger';
+/**
+ * Result object from paginated API calls
+ * Expected structure for services using this utility
+ */
+export interface PaginatedResult<T> {
+    /** Array of items returned from this page */
+    items: T[];
+    /** Current page number */
+    page: number;
+    /** Page size/limit for this request */
+    limit: number;
+    /** Total count of all items across all pages */
+    total: number;
+    /** Total number of pages available */
+    totalPages: number;
+    /** Whether there is a next page available */
+    hasNext: boolean;
+    /** Whether there is a previous page available */
+    hasPrevious: boolean;
+}
+/**
+ * Options for auto-pagination
+ */
+export interface AutoPaginationOptions {
+    /** 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;
+}
+/**
+ * Result object from auto-pagination
+ */
+export interface AutoPaginationResult<T> {
+    /** All items from all pages combined */
+    items: T[];
+    /** Total count from the API (across all pages) */
+    total: number;
+}
+/**
+ * Generic auto-pagination handler
+ *
+ * Automatically iterates through all pages of paginated API results
+ * and combines them into a single array. Handles common patterns like:
+ * - Safety limits to prevent infinite loops
+ * - Empty result detection
+ * - Debug logging of pagination progress
+ * - Preserves total count from the API
+ *
+ * @typeParam T - Type of items being paginated
+ * @param fetchFn Function that fetches a single page of results
+ * @param options Pagination options (maxPages, logger, pageSize)
+ * @returns Promise<AutoPaginationResult> All items and total count from the API
+ *
+ * @example
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { maxPages: 1000, pageSize: 20, logger }
+ * );
+ * console.log(`Total: ${result.total}, Fetched: ${result.items.length}`);
+ * ```
+ *
+ * @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
+ *
+ * Helper function to construct the standard paginated result structure
+ * when returning combined results from auto-pagination. Supports custom item
+ * key naming for service-specific result structures (pools, snapshots, etc.).
+ *
+ * Eliminates 5-7 line response object construction patterns found in:
+ * - DexPoolService.fetchAllDexPools() (lines 209-219)
+ * - PriceHistoryService.fetchAllPriceHistory() (lines 433-442)
+ * - Other services with similar patterns
+ *
+ * @typeParam T - Type of items in the result
+ * @param items Combined array of all items from all pages
+ * @param total Total count from last page (or sum of counts)
+ * @param itemsKey Optional field name for items (default: 'items'). Use for service-specific naming like 'pools', 'snapshots', 'comments'
+ * @returns PaginatedResult object with items flattened into a single "page"
+ *
+ * @example Basic usage (default 'items' key)
+ * ```typescript
+ * const allItems = await autoPaginate(fetchFn);
+ * return buildPaginatedResult(allItems.items, allItems.total);
+ * // Returns: { items, page: 1, limit, total, totalPages: 1, hasNext: false, hasPrevious: false }
+ * ```
+ *
+ * @example With custom items key (eliminates manual response construction)
+ * ```typescript
+ * // DexPoolService - before (7 lines)
+ * const result = buildPaginatedResult(paginationResult.items, paginationResult.total);
+ * return {
+ *   pools: result.items,
+ *   page: result.page,
+ *   limit: result.limit,
+ *   total: result.total,
+ *   totalPages: result.totalPages,
+ *   hasNext: result.hasNext,
+ *   hasPrevious: result.hasPrevious,
+ * };
+ *
+ * // DexPoolService - after (1 line)
+ * return buildPaginatedResult(paginationResult.items, paginationResult.total, 'pools');
+ * ```
+ *
+ * @example Other service patterns
+ * ```typescript
+ * // PriceHistoryService
+ * return buildPaginatedResult(paginationResult.items, paginationResult.total, 'snapshots');
+ *
+ * // CommentService
+ * return buildPaginatedResult(allComments, totalCount, 'comments');
+ * ```
+ *
+ * @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>;
+//# sourceMappingURL=auto-pagination.d.ts.map

package/dist/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,GAAG,CAAC,CAerB"}

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

@@ -0,0 +1,336 @@
+/**
+ * BigNumber utility helpers for common calculations
+ *
+ * Consolidates repeated BigNumber patterns and operations to reduce
+ * code duplication across services, particularly in GSwapService.
+ *
+ * Common patterns extracted:
+ * - Slippage factor calculation
+ * - Min/max output calculation with slippage
+ * - Tick to sqrt ratio conversion (1.0001^(tick/2))
+ * - Price inversion
+ * - Safe BigNumber creation
+ *
+ * @internal
+ */
+import BigNumber from 'bignumber.js';
+/**
+ * Create a BigNumber from a numeric value with safe defaults
+ *
+ * @param value The value to convert
+ * @param defaultValue Value to use if input is null/undefined/zero-length string (default: "0")
+ * @returns BigNumber instance
+ *
+ * @example
+ * ```typescript
+ * const balance = toBigNumber(userData.balance || 0);
+ * const amount = toBigNumber(params.amount); // Uses "0" if undefined
+ * ```
+ */
+export declare function toBigNumber(value: string | number | BigNumber | null | undefined, defaultValue?: string | number): BigNumber;
+/**
+ * Create a BigNumber and immediately call toFixed()
+ *
+ * Convenience method for the pattern: `new BigNumber(value).toFixed()`
+ * Used for serializing calculated amounts back to strings.
+ *
+ * @param value The value to convert
+ * @param decimals Number of decimal places (default: undefined = max precision)
+ * @returns Fixed string representation
+ *
+ * @example
+ * ```typescript
+ * const minOutput = toBigNumberFixed(calculated, 6);  // "123.456789"
+ * const slippageAdjusted = toBigNumberFixed(amount.multipliedBy(0.99));
+ * ```
+ */
+export declare function toBigNumberFixed(value: string | number | BigNumber | null | undefined, decimals?: number): string;
+/**
+ * Calculate slippage-adjusted minimum output
+ *
+ * Consolidates the pattern:
+ * ```typescript
+ * const slippageFactor = new BigNumber(1).minus(slippageTolerance);
+ * const minOutput = estimatedOutput.multipliedBy(slippageFactor);
+ * ```
+ *
+ * @param estimatedOutput The estimated output amount
+ * @param slippageTolerance Slippage tolerance as decimal (e.g., 0.01 for 1%)
+ * @returns Minimum acceptable output after slippage
+ *
+ * @example
+ * ```typescript
+ * const quote = await sdk.getSwapQuote('GALA', 'GUSDC', '100');
+ * const minOutput = calculateSlippageAdjustedAmount(
+ *   quote.estimatedOutput,
+ *   0.01  // 1% slippage
+ * );
+ * await sdk.executeSwap(..., minOutput.toFixed());
+ * ```
+ */
+export declare function calculateSlippageAdjustedAmount(estimatedOutput: string | number | BigNumber, slippageTolerance?: number): BigNumber;
+/**
+ * Calculate slippage factor (1 - tolerance)
+ *
+ * Consolidates: `new BigNumber(1).minus(tolerance)`
+ * Used as multiplier for slippage calculations.
+ *
+ * @param tolerance Slippage tolerance as decimal (e.g., 0.01 for 1%)
+ * @returns Slippage factor (e.g., 0.99 for 1% tolerance)
+ *
+ * @example
+ * ```typescript
+ * const factor = calculateSlippageFactor(0.01);  // BigNumber(0.99)
+ * const minAmount = estimatedAmount.multipliedBy(factor);
+ * ```
+ */
+export declare function calculateSlippageFactor(tolerance?: number): BigNumber;
+/**
+ * Convert tick to sqrt ratio for 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 price in Q64.96 format
+ *
+ * @example
+ * ```typescript
+ * const lowerSqrtRatio = tickToSqrtRatio(tickLower);
+ * 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 production-grade @gala-chain/dex math.
+ * Formula: tick = log_1.0001(price)
+ *
+ * @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)
+ *
+ * Consolidates: `new BigNumber(1).dividedBy(price)`
+ * Used for converting price direction (e.g., BTC/USD → USD/BTC).
+ *
+ * @param price The price to invert
+ * @param asFixed Whether to return as fixed string (default: false returns BigNumber)
+ * @returns Inverted price as BigNumber or string
+ *
+ * @example
+ * ```typescript
+ * const galuPrice = invertPrice('0.50');  // 2.0
+ * const displayPrice = invertPrice(price, true);  // "2.0" (string)
+ * ```
+ */
+export declare function invertPrice(price: string | number | BigNumber, asFixed?: boolean): BigNumber | string;
+/**
+ * Q96 constant for Uniswap V3 calculations (2^96)
+ *
+ * Consolidates: `new BigNumber(2).pow(96)`
+ * Used in tick-based liquidity calculations.
+ *
+ * @returns Q96 value as BigNumber
+ *
+ * @example
+ * ```typescript
+ * const Q96 = getQ96Constant();  // 2^96
+ * const adjustedPrice = sqrtPrice.multipliedBy(sqrtPrice).dividedBy(Q96);
+ * ```
+ */
+export declare function getQ96Constant(): BigNumber;
+/**
+ * Find minimum of two BigNumber values
+ *
+ * Convenience wrapper for `BigNumber.min()` with safe input handling.
+ *
+ * @param a First value
+ * @param b Second value
+ * @returns The minimum value as BigNumber
+ *
+ * @example
+ * ```typescript
+ * const liquidity0 = calculateFromAmount0(...);
+ * const liquidity1 = calculateFromAmount1(...);
+ * const optimalLiquidity = minBigNumber(liquidity0, liquidity1);
+ * ```
+ */
+export declare function minBigNumber(a: string | number | BigNumber, b: string | number | BigNumber): BigNumber;
+/**
+ * Find maximum of two BigNumber values
+ *
+ * Convenience wrapper for `BigNumber.max()` with safe input handling.
+ *
+ * @param a First value
+ * @param b Second value
+ * @returns The maximum value as BigNumber
+ *
+ * @example
+ * ```typescript
+ * const amount0 = parseFloat(poolData.amount0);
+ * const amount1 = parseFloat(poolData.amount1);
+ * const maxAmount = maxBigNumber(amount0, amount1);
+ * ```
+ */
+export declare function maxBigNumber(a: string | number | BigNumber, b: string | number | BigNumber): BigNumber;
+/**
+ * Check if a value is zero
+ *
+ * Safe check for zero with BigNumber precision.
+ *
+ * @param value The value to check
+ * @returns true if value equals 0
+ *
+ * @example
+ * ```typescript
+ * if (isZero(amount)) {
+ *   throw new Error('Amount cannot be zero');
+ * }
+ * ```
+ */
+export declare function isZero(value: string | number | BigNumber): boolean;
+/**
+ * Check if a value is positive
+ *
+ * @param value The value to check
+ * @returns true if value > 0
+ *
+ * @example
+ * ```typescript
+ * if (isPositive(balance)) {
+ *   // user has funds
+ * }
+ * ```
+ */
+export declare function isPositive(value: string | number | BigNumber): boolean;
+/**
+ * Check if a value is negative
+ *
+ * @param value The value to check
+ * @returns true if value < 0
+ */
+export declare function isNegative(value: string | number | BigNumber): boolean;
+/**
+ * Check if value is between two bounds (inclusive)
+ *
+ * @param value The value to check
+ * @param min Lower bound (inclusive)
+ * @param max Upper bound (inclusive)
+ * @returns true if min <= value <= max
+ *
+ * @example
+ * ```typescript
+ * if (isBetween(price, minPrice, maxPrice)) {
+ *   // price is in valid range
+ * }
+ * ```
+ */
+export declare function isBetween(value: string | number | BigNumber, min: string | number | BigNumber, max: string | number | BigNumber): boolean;
+/**
+ * Calculate percentage of a value
+ *
+ * @param value The base value
+ * @param percentage The percentage to calculate (e.g., 10 for 10%)
+ * @returns The percentage amount
+ *
+ * @example
+ * ```typescript
+ * const fee = calculatePercentage(amount, 0.3);  // 0.3% fee
+ * const netAmount = amount.minus(fee);
+ * ```
+ */
+export declare function calculatePercentage(value: string | number | BigNumber, percentage: number): BigNumber;
+/**
+ * Increase a value by a percentage
+ *
+ * @param value The base value
+ * @param percentage The percentage to increase (e.g., 10 for 10% increase)
+ * @returns The increased value
+ *
+ * @example
+ * ```typescript
+ * const withSlippage = increaseByPercentage(amount, 1);  // 1% increase
+ * ```
+ */
+export declare function increaseByPercentage(value: string | number | BigNumber, percentage: number): BigNumber;
+/**
+ * Decrease a value by a percentage
+ *
+ * @param value The base value
+ * @param percentage The percentage to decrease (e.g., 1 for 1% decrease)
+ * @returns The decreased value
+ *
+ * @example
+ * ```typescript
+ * const afterSlippage = decreaseByPercentage(amount, 1);  // 1% decrease
+ * ```
+ */
+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/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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"}