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

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

@@ -0,0 +1,208 @@
+/**
+ * Service Error Handling Wrapper
+ *
+ * Reduces duplication in error handling across services by providing a single,
+ * reusable wrapper for try/catch blocks with consistent logging and error transformation.
+ *
+ * Replaces the pattern of:
+ * ```typescript
+ * try {
+ *   return await operation();
+ * } catch (error) {
+ *   logger?.error(`${context}:`, error);
+ *   throw handleNetworkError(error, context);
+ * }
+ * ```
+ *
+ * With a single function call:
+ * ```typescript
+ * return withErrorHandling(() => operation(), context, logger);
+ * ```
+ *
+ * @category Utilities
+ * @since 5.12.0
+ */
+import type { Logger } from './Logger';
+/**
+ * Wraps an async operation with standardized error handling and logging
+ *
+ * This wrapper eliminates duplicate try/catch blocks across services by:
+ * 1. Executing the provided operation
+ * 2. Logging any errors that occur
+ * 3. Transforming errors into NetworkError via handleNetworkError
+ * 4. Re-throwing the transformed error
+ *
+ * ## Reduces Code Duplication
+ *
+ * ### Before (50+ instances across services):
+ * ```typescript
+ * async fetchUserAssets(address: string): Promise<UserAsset[]> {
+ *   try {
+ *     const response = await this.dexBackendClient.get('/user-assets', { address });
+ *     return response.data;
+ *   } catch (error) {
+ *     this.logger.error('Failed to fetch user assets:', error);
+ *     throw handleNetworkError(error, 'Failed to fetch user assets');
+ *   }
+ * }
+ *
+ * async getSwapQuote(params: SwapQuoteParams): Promise<SwapQuoteResult> {
+ *   try {
+ *     const result = await this.dexQuoteService.quote(params);
+ *     return result;
+ *   } catch (error) {
+ *     this.logger.error('Failed to get swap quote:', error);
+ *     throw handleNetworkError(error, 'Failed to get swap quote');
+ *   }
+ * }
+ * ```
+ *
+ * ### After (Clean, DRY):
+ * ```typescript
+ * async fetchUserAssets(address: string): Promise<UserAsset[]> {
+ *   return withErrorHandling(
+ *     () => this.dexBackendClient.get('/user-assets', { address }).then(r => r.data),
+ *     'Failed to fetch user assets',
+ *     this.logger
+ *   );
+ * }
+ *
+ * async getSwapQuote(params: SwapQuoteParams): Promise<SwapQuoteResult> {
+ *   return withErrorHandling(
+ *     () => this.dexQuoteService.quote(params),
+ *     'Failed to get swap quote',
+ *     this.logger
+ *   );
+ * }
+ * ```
+ *
+ * ## Benefits
+ * - **Code reduction**: ~2 lines per method instead of 6
+ * - **Consistency**: All services use identical error handling
+ * - **Maintainability**: Single place to update error handling logic
+ * - **Type safety**: Generic type T ensures return type preservation
+ * - **Optional logging**: Logger is optional for flexibility
+ * - **Flexible error handlers**: Optional custom errorHandler for service-specific logic
+ *
+ * @template T The return type of the operation
+ * @param operation An async function that performs the actual work
+ * @param context Human-readable description of what failed (for logging and error messages)
+ * @param logger Optional logger instance (logs error if provided)
+ * @param errorHandler Optional custom error handler (defaults to handleNetworkError)
+ * @returns Promise resolving to the operation result
+ * @throws NetworkError (or custom error from errorHandler) containing the context and original error details
+ *
+ * @example Basic usage with logger
+ * ```typescript
+ * async fetchTokens(): Promise<Token[]> {
+ *   return withErrorHandling(
+ *     async () => {
+ *       const response = await this.http.get('/tokens');
+ *       return response.data;
+ *     },
+ *     'Failed to fetch tokens',
+ *     this.logger
+ *   );
+ * }
+ * ```
+ *
+ * @example Without logger
+ * ```typescript
+ * const data = await withErrorHandling(
+ *   async () => externalService.getData(),
+ *   'External service call failed'
+ * );
+ * ```
+ *
+ * @example With custom error handler
+ * ```typescript
+ * async getSwapQuote(params: SwapQuoteParams): Promise<SwapQuoteResult> {
+ *   return withErrorHandling(
+ *     () => this.dexQuoteService.quote(params),
+ *     'Failed to get swap quote',
+ *     this.logger,
+ *     (error, context, logger) => {
+ *       // Custom error handling for GSwap-specific logic (wrapper already logs)
+ *       throw new GSwapQuoteError(`${context}: ${getErrorMessage(error)}`, error);
+ *     }
+ *   );
+ * }
+ * ```
+ *
+ * @example With complex operation
+ * ```typescript
+ * async processTransaction(): Promise<TransactionResult> {
+ *   return withErrorHandling(
+ *     async () => {
+ *       const pool = await this.getPool(token);
+ *       const quote = await this.getQuote(pool);
+ *       return this.executeSwap(quote);
+ *     },
+ *     'Failed to process transaction',
+ *     this.logger
+ *   );
+ * }
+ * ```
+ *
+ * @example Sync operations (use async wrapper)
+ * ```typescript
+ * async validateAndFetch(tokenName: string): Promise<TokenData> {
+ *   return withErrorHandling(
+ *     async () => {
+ *       validateTokenName(tokenName); // Sync validation
+ *       return this.fetch(tokenName); // Async fetch
+ *     },
+ *     `Failed to fetch token: ${tokenName}`,
+ *     this.logger
+ *   );
+ * }
+ * ```
+ */
+export declare function withErrorHandling<T>(operation: () => Promise<T>, context: string, logger?: Logger, errorHandler?: (error: unknown, context: string, logger: Logger | undefined) => never): Promise<T>;
+/**
+ * Wraps a synchronous operation with standardized error handling and logging
+ *
+ * Same as withErrorHandling but for sync operations. Useful for validation
+ * or data transformation that might throw errors.
+ *
+ * @template T The return type of the operation
+ * @param operation A synchronous function that performs the actual work
+ * @param context Human-readable description of what failed
+ * @param logger Optional logger instance
+ * @param errorHandler Optional custom error handler (defaults to handleNetworkError)
+ * @returns The operation result
+ * @throws NetworkError (or custom error from errorHandler) containing the context and original error details
+ *
+ * @example Sync operation
+ * ```typescript
+ * function validateToken(tokenName: string): void {
+ *   return withErrorHandlingSync(
+ *     () => validateTokenNameFormat(tokenName),
+ *     `Invalid token name: ${tokenName}`,
+ *     this.logger
+ *   );
+ * }
+ * ```
+ *
+ * @example Sync operation with custom error handler
+ * ```typescript
+ * function validateAndTransform(tokenName: string): TokenData {
+ *   return withErrorHandlingSync(
+ *     () => {
+ *       validateTokenNameFormat(tokenName);
+ *       return transformToken(tokenName);
+ *     },
+ *     `Failed to validate token: ${tokenName}`,
+ *     this.logger,
+ *     (error, context, logger) => {
+ *       logger?.error(`${context}:`, error);
+ *       throw new ValidationError(`${context}: ${getErrorMessage(error)}`, 'tokenName');
+ *     }
+ *   );
+ * }
+ * ```
+ *
+ * @since 5.12.0
+ */
+export declare function withErrorHandlingSync<T>(operation: () => T, context: string, logger?: Logger, errorHandler?: (error: unknown, context: string, logger: Logger | undefined) => never): T;
+//# sourceMappingURL=error-wrapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-wrapper.d.ts","sourceRoot":"","sources":["../../../src/utils/error-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsIG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,KAAK,GACpF,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,SAAS,EAAE,MAAM,CAAC,EAClB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,KAAK,GACpF,CAAC,CAmBH"}

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

@@ -7,6 +7,76 @@
  * @category Utilities
  * @since 3.6.5
  */
+/**
+ * Standard error codes for ValidationError
+ *
+ * Use these constants instead of string literals for:
+ * - IDE autocomplete support
+ * - Typo prevention
+ * - Consistent error handling across the SDK
+ *
+ * @example
+ * ```typescript
+ * import { ValidationError, ERROR_CODES } from '../utils/errors';
+ *
+ * throw new ValidationError('tokenName is required', 'tokenName', ERROR_CODES.REQUIRED);
+ * ```
+ *
+ * @since 6.3.0
+ */
+export declare const ERROR_CODES: {
+    /** Field is null, undefined, or missing */
+    readonly REQUIRED: "REQUIRED";
+    /** Field has wrong type (string expected, got number, etc.) */
+    readonly INVALID_TYPE: "INVALID_TYPE";
+    /** Field value is outside acceptable range or set */
+    readonly INVALID_VALUE: "INVALID_VALUE";
+    /** Field doesn't match required pattern (regex) */
+    readonly INVALID_FORMAT: "INVALID_FORMAT";
+    /** Field length is below minimum */
+    readonly TOO_SHORT: "TOO_SHORT";
+    /** Field length exceeds maximum */
+    readonly TOO_LONG: "TOO_LONG";
+    /** Numeric value exceeds maximum */
+    readonly TOO_LARGE: "TOO_LARGE";
+    /** Numeric value is below minimum */
+    readonly TOO_SMALL: "TOO_SMALL";
+    /** Array is empty when it shouldn't be */
+    readonly EMPTY_ARRAY: "EMPTY_ARRAY";
+    /** Array exceeds maximum length */
+    readonly ARRAY_TOO_LARGE: "ARRAY_TOO_LARGE";
+    /** Value is zero when non-zero expected */
+    readonly ZERO_VALUE: "ZERO_VALUE";
+    /** Tick spacing doesn't match fee tier requirements */
+    readonly INVALID_TICK_SPACING: "INVALID_TICK_SPACING";
+    /** Fee tier is not valid (500, 3000, 10000) */
+    readonly INVALID_FEE_TIER: "INVALID_FEE_TIER";
+    /** Price range is invalid (min >= max) */
+    readonly INVALID_RANGE: "INVALID_RANGE";
+    /** HTTP request parameters are invalid */
+    readonly INVALID_PARAMETERS: "INVALID_PARAMETERS";
+    /** Resource (position, pool, etc.) not found */
+    readonly NOT_FOUND: "NOT_FOUND";
+    /** Position data is malformed or incomplete */
+    readonly INVALID_DATA: "INVALID_DATA";
+};
+/**
+ * Type for error codes - use for type-safe error code handling
+ *
+ * @example
+ * ```typescript
+ * function handleError(code: ErrorCode) {
+ *   switch (code) {
+ *     case ERROR_CODES.REQUIRED:
+ *       return 'This field is required';
+ *     case ERROR_CODES.INVALID_FORMAT:
+ *       return 'Invalid format';
+ *     // ... other cases
+ *   }
+ * }
+ * ```
+ */
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
 /**
  * Error thrown when validation fails
  *

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

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

package/dist/src/utils/http-factory.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HTTP Client Factory
+ *
+ * Factory function for creating standardized HTTP clients with consistent configuration.
+ * Eliminates boilerplate axios.create() calls across services.
+ *
+ * @category Utilities
+ * @since 6.6.0
+ */
+import { AxiosInstance } from 'axios';
+/**
+ * Creates a standardized HTTP client (AxiosInstance) with baseURL and timeout configuration
+ *
+ * Factory function that eliminates repeated axios.create() boilerplate by providing
+ * consistent default configuration across all HTTP clients.
+ *
+ * @param baseUrl Base URL for all requests made by this client
+ * @param timeout Request timeout in milliseconds (default: 30000)
+ * @returns Configured AxiosInstance ready for HTTP requests
+ *
+ * @example Basic usage
+ * ```typescript
+ * const httpClient = createHttpExecutor('https://api.example.com', 30000);
+ * const response = await httpClient.get('/data');
+ * ```
+ *
+ * @example Default timeout
+ * ```typescript
+ * const httpClient = createHttpExecutor('https://api.example.com');
+ * // Uses default 30000ms timeout
+ * ```
+ *
+ * @since 6.6.0
+ */
+export declare function createHttpExecutor(baseUrl: string, timeout?: number): AxiosInstance;
+//# sourceMappingURL=http-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-factory.d.ts","sourceRoot":"","sources":["../../../src/utils/http-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAc,GACtB,aAAa,CAQf"}

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

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

package/dist/src/utils/load-env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-env.d.ts","sourceRoot":"","sources":["../../../src/utils/load-env.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAY1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CASvE;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjF"}
+{"version":3,"file":"load-env.d.ts","sourceRoot":"","sources":["../../../src/utils/load-env.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAY1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAWvE;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjF"}

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

@@ -1 +1 @@
-{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../../../src/utils/multipart.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAGnC,QAAQ,CAAC,EAAE,MAAM;IACjB,QAAQ,CAAC,EAAE,MAAM;gBAFxB,OAAO,EAAE,MAAM,EACR,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,QAAQ,CAAC,EAAE,MAAM,YAAA;CAK3B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,GAAG,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAiGN;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CASzD;AA0BD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,QAAQ,CAiBV;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA0CnD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAwB9C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAM3C"}
+{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../../../src/utils/multipart.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAGnC,QAAQ,CAAC,EAAE,MAAM;IACjB,QAAQ,CAAC,EAAE,MAAM;gBAFxB,OAAO,EAAE,MAAM,EACR,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,QAAQ,CAAC,EAAE,MAAM,YAAA;CAK3B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,GAAG,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAmGN;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CASzD;AA0BD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,QAAQ,CAiBV;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA0CnD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAwB9C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAM3C"}

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

@@ -0,0 +1,289 @@
+/**
+ * Numeric Calculation Patterns
+ *
+ * High-level numeric patterns for bonding curve fees, Uniswap V3 tick management,
+ * percentile calculations, and safe division with thresholds.
+ *
+ * Consolidates 20+ occurrences of repeated mathematical patterns across trading,
+ * liquidity, and portfolio services.
+ *
+ * @category Utilities
+ * @since 5.17.0
+ */
+import BigNumber from 'bignumber.js';
+/**
+ * Calculate linearly interpolated fee between min and max based on progress
+ *
+ * Maps a progress value (0 to 1) to a fee between minFee and maxFee using linear interpolation.
+ * This is the core pattern used in bonding curve calculations where fees scale from
+ * minFeePortion to maxFeePortion based on token supply progress (supply / maxSupply).
+ *
+ * Formula: minFee + (maxFee - minFee) * progress
+ *
+ * Consolidates 4 occurrences in bondingCurveCalculations and related services.
+ *
+ * @param progress - Progress ratio from 0 to 1 (e.g., currentSupply / maxSupply)
+ * @param minFee - Minimum fee value (as decimal, e.g., 0.1 for 10%)
+ * @param maxFee - Maximum fee value (as decimal, e.g., 0.5 for 50%)
+ * @returns Interpolated fee amount as BigNumber
+ *
+ * @throws Error if progress is outside [0, 1] or if maxFee < minFee
+ *
+ * @example
+ * ```typescript
+ * // Fee scales from 10% to 50% as supply increases
+ * const progress = toBigNumber('500000').dividedBy('10000000'); // 0.05 = 5%
+ * const fee = calculateLinearFeeInterpolation(progress, 0.1, 0.5);
+ * // Returns: 0.1 + (0.5 - 0.1) * 0.05 = 0.12 (12%)
+ *
+ * // At max supply (100%), fee reaches 50%
+ * const fee = calculateLinearFeeInterpolation(1, 0.1, 0.5);
+ * // Returns: 0.5
+ *
+ * // At zero supply (0%), fee is minimum
+ * const fee = calculateLinearFeeInterpolation(0, 0.1, 0.5);
+ * // Returns: 0.1
+ * ```
+ */
+export declare function calculateLinearFeeInterpolation(progress: number | BigNumber, minFee: number, maxFee: number): BigNumber;
+/**
+ * Round tick boundaries to valid Uniswap V3 spacing multiples
+ *
+ * Uniswap V3 ticks must be multiples of tickSpacing (1, 10, 60, 200, etc.).
+ * This utility rounds tickLower down and tickUpper up to valid boundaries.
+ *
+ * Consolidates 5 occurrences of inline Math.floor/Math.ceil logic in GSwap services.
+ *
+ * @param tickLower - Lower tick boundary (before rounding)
+ * @param tickUpper - Upper tick boundary (before rounding)
+ * @param tickSpacing - Tick spacing requirement (e.g., 60 for 0.3% fee tier)
+ * @returns Object with rounded tickLower (floor) and tickUpper (ceil)
+ *
+ * @throws Error if tickLower >= tickUpper or if tickSpacing <= 0
+ *
+ * @example
+ * ```typescript
+ * // Round to nearest 60-tick multiples
+ * const rounded = roundTickBoundaries(1234, 5678, 60);
+ * // Returns: { tickLower: 1200, tickUpper: 5700 }
+ * // (1234 rounds down to 1200, 5678 rounds up to 5700)
+ *
+ * // Handle negative ticks (below price 1.0)
+ * const rounded = roundTickBoundaries(-1234, -1000, 10);
+ * // Returns: { tickLower: -1240, tickUpper: -1000 }
+ *
+ * // Ticks already valid (multiples of spacing)
+ * const rounded = roundTickBoundaries(0, 60, 60);
+ * // Returns: { tickLower: 0, tickUpper: 60 }
+ * ```
+ */
+export declare function roundTickBoundaries(tickLower: number, tickUpper: number, tickSpacing: number): {
+    tickLower: number;
+    tickUpper: number;
+};
+/**
+ * Map price range to tick range and return both computed ticks and actual prices
+ *
+ * Converts a human-readable price range to Uniswap V3 ticks, then converts back
+ * to compute the actual prices those ticks represent (due to rounding effects).
+ *
+ * This bidirectional mapping is essential for liquidity position validation where
+ * users specify a price range but the actual executable range differs due to
+ * tick quantization.
+ *
+ * Consolidates 3 occurrences of price-tick conversion with validation logic.
+ *
+ * @param minPrice - Minimum price (human-readable, e.g., "0.95")
+ * @param maxPrice - Maximum price (human-readable, e.g., "1.05")
+ * @param tickSpacing - Tick spacing requirement (default: 60)
+ * @returns Object with computed ticks and the actual prices they represent
+ *
+ * @throws Error if minPrice >= maxPrice or if prices are non-positive
+ *
+ * @example
+ * ```typescript
+ * // Map price range [0.95, 1.05] to ticks with 60-tick spacing
+ * const mapping = priceTickRangeMapping('0.95', '1.05', 60);
+ * // Returns: {
+ * //   minTick: -2700,
+ * //   maxTick: 1320,
+ * //   actualMinPrice: BigNumber('0.949...'),  // Slightly lower due to rounding
+ * //   actualMaxPrice: BigNumber('1.050...')   // Slightly higher due to rounding
+ * // }
+ *
+ * // Confirms to user: "You requested [0.95, 1.05] but will get [0.949..., 1.050...]"
+ * ```
+ */
+export declare function priceTickRangeMapping(minPrice: string | number | BigNumber, maxPrice: string | number | BigNumber, tickSpacing?: number): {
+    minTick: number;
+    maxTick: number;
+    actualMinPrice: BigNumber;
+    actualMaxPrice: BigNumber;
+};
+/**
+ * Calculate percentile index in a sorted array
+ *
+ * Computes the array index corresponding to a given percentile (0-100).
+ * Uses linear interpolation for fractional positions.
+ *
+ * Consolidates 3 occurrences of percentile calculations in monitoring metrics.
+ *
+ * @param sortedArray - Array of numbers, must be sorted in ascending order
+ * @param percentile - Percentile value from 0 to 100 (e.g., 95 for 95th percentile)
+ * @returns The array index, or -1 if array is empty
+ *
+ * @throws Error if percentile is outside [0, 100] or array is not sorted
+ *
+ * @example
+ * ```typescript
+ * // Get 95th percentile from latency measurements
+ * const latencies = [10, 25, 50, 75, 100, 150, 200];
+ * const p95Index = percentileIndexCalculation(latencies, 95);
+ * // Returns index 6 (value 200, or interpolated between 150-200)
+ *
+ * // Median (50th percentile)
+ * const medianIndex = percentileIndexCalculation(latencies, 50);
+ * // Returns index 3 (value 75)
+ *
+ * // Min/Max
+ * const minIndex = percentileIndexCalculation(latencies, 0);   // 0
+ * const maxIndex = percentileIndexCalculation(latencies, 100); // 6
+ * ```
+ */
+export declare function percentileIndexCalculation(sortedArray: number[], percentile: number): number;
+/**
+ * Round decimal up to specified precision (ceiling rounding)
+ *
+ * Always rounds UP to the specified decimal places. This ensures system accuracy
+ * and prevents shortchanging calculations (e.g., fee calculations always round up
+ * to protect the fee recipient).
+ *
+ * Consolidates 3 occurrences of Math.ceil with decimal precision patterns.
+ *
+ * @param value - Value to round (string, number, or BigNumber)
+ * @param decimals - Number of decimal places to preserve
+ * @returns Rounded value as BigNumber
+ *
+ * @throws Error if decimals is negative
+ *
+ * @example
+ * ```typescript
+ * // Fee calculations that always round up
+ * const fee = decimalRoundingUp('1.234', 2);  // 1.24 (rounds up from 1.23)
+ *
+ * // Preserve more decimals
+ * const precise = decimalRoundingUp('1.23456', 4);  // 1.2346
+ *
+ * // Integer rounding
+ * const integer = decimalRoundingUp('1.1', 0);  // 2 (rounds up to next integer)
+ *
+ * // Very small values
+ * const tiny = decimalRoundingUp('0.00001', 4);  // 0.0001
+ * ```
+ */
+export declare function decimalRoundingUp(value: string | number | BigNumber, decimals: number): BigNumber;
+/**
+ * Divide with zero fallback AND minimum threshold check
+ *
+ * Performs safe division with two layers of protection:
+ * 1. Returns fallback if denominator is zero
+ * 2. Returns minimum threshold if computed result is less than minimum
+ *
+ * This prevents calculations from producing unrealistic micro-values (e.g., APR
+ * calculations that shouldn't return 0.0000001%).
+ *
+ * Consolidates 3 partial occurrences across APR and portfolio calculations.
+ *
+ * @param numerator - Dividend
+ * @param denominator - Divisor
+ * @param minimum - Minimum threshold (default: "0", meaning no minimum)
+ * @param fallback - Value to return if denominator is zero (default: "0")
+ * @returns The quotient, minimum threshold if result is too small, or fallback if denominator is zero
+ *
+ * @throws Error if minimum is negative or minimum > maximum representable value
+ *
+ * @example
+ * ```typescript
+ * // Safe division with zero fallback
+ * const ratio = safeDivideWithMinimum('100', '0', undefined, '0');
+ * // Returns: "0" (denominator is zero)
+ *
+ * // Enforce minimum APR (never report less than 0.01%)
+ * const apr = safeDivideWithMinimum(
+ *   feeAmount,
+ *   liquidityValue,
+ *   '0.0001'  // Minimum 0.01% APR
+ * );
+ *
+ * // Threshold prevents micro-values
+ * const tiny = safeDivideWithMinimum('1', '1000000', '0.001');
+ * // Result 0.000001 is < minimum 0.001, so returns 0.001
+ *
+ * // Normal division (result meets threshold)
+ * const normal = safeDivideWithMinimum('100', '10', '0.001');
+ * // Result 10 > minimum 0.001, so returns 10
+ * ```
+ */
+export declare function safeDivideWithMinimum(numerator: string | number | BigNumber, denominator: string | number | BigNumber, minimum?: string | number | BigNumber, fallback?: string | number | BigNumber): BigNumber;
+/**
+ * Round a Uniswap V3 tick to a valid spacing multiple
+ *
+ * Uniswap V3 ticks must be multiples of tickSpacing (e.g., 1, 10, 60, 200).
+ * This utility rounds down to the nearest valid tick spacing using integer arithmetic.
+ *
+ * Formula: `Math.floor(tick / tickSpacing) * tickSpacing`
+ *
+ * Consolidates 4 occurrences of inline tick rounding logic in GSwap services.
+ *
+ * @param tick - The tick value to round (can be negative for prices below 1.0)
+ * @param tickSpacing - The tick spacing requirement (e.g., 1, 10, 60, 200)
+ * @returns The rounded tick (multiple of tickSpacing)
+ *
+ * @throws Error if tickSpacing <= 0
+ *
+ * @example
+ * ```typescript
+ * // Round tick 1055 to nearest tick spacing of 10
+ * const rounded = roundTickToSpacing(1055, 10);  // 1050
+ *
+ * // Round tick 101 to spacing 60
+ * const rounded = roundTickToSpacing(101, 60);   // 60
+ *
+ * // Negative ticks are also supported (for prices below 1.0)
+ * const rounded = roundTickToSpacing(-1055, 10); // -1060
+ * ```
+ */
+export declare function roundTickToSpacing(tick: number, tickSpacing: number): number;
+/**
+ * Calculate reverse bonding curve fee amount with precision handling
+ *
+ * Consolidates the pattern of applying a fee factor to a base amount with
+ * integer rounding (down). Used extensively in bonding curve calculations
+ * for reverse fee computation and scaled amount operations.
+ *
+ * Formula: `new BigNumber(baseAmount).multipliedBy(feeFactor).integerValue(BigNumber.ROUND_DOWN)`
+ *
+ * Consolidates 3 occurrences of fee scaling patterns in trading services.
+ *
+ * @param baseAmount - The base amount to apply fee factor to (string, number, or BigNumber)
+ * @param feeFactor - The fee factor as decimal (e.g., 0.1 for 10%, 0.005 for 0.5%)
+ * @returns The scaled fee amount (rounded down to integer)
+ *
+ * @throws Error if feeFactor is negative
+ *
+ * @example
+ * ```typescript
+ * // Calculate 1% fee on 1000 GALA
+ * const baseAmount = new BigNumber('1000');
+ * const fee = calculateScaledFeeAmount(baseAmount, 0.01);  // BigNumber(10)
+ *
+ * // Calculate 0.5% reverse bonding curve fee
+ * const feeAmount = calculateScaledFeeAmount('5000', 0.005);  // BigNumber(25)
+ *
+ * // Fee factor from pool: reverseBondingCurveFee = 0.123456
+ * const reversed = calculateScaledFeeAmount(amount, reverseBondingCurveFee);
+ * // Returns: rounded-down result of amount * 0.123456
+ * ```
+ */
+export declare function calculateScaledFeeAmount(baseAmount: string | number | BigNumber, feeFactor: number): BigNumber;
+//# sourceMappingURL=numeric-patterns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/numeric-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AAGrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,SAAS,CAiBX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAmB1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACrC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACrC,WAAW,GAAE,MAAW,GACvB;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,SAAS,CAAC;IAC1B,cAAc,EAAE,SAAS,CAAC;CAC3B,CAiCA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EAAE,EACrB,UAAU,EAAE,MAAM,GACjB,MAAM,CAeR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,QAAQ,EAAE,MAAM,GACf,SAAS,CAUX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACtC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACxC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACrC,QAAQ,GAAE,MAAM,GAAG,MAAM,GAAG,SAAe,GAC1C,SAAS,CAyBX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACvC,SAAS,EAAE,MAAM,GAChB,SAAS,CAMX"}