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

package/dist/src/utils/safe-parsers.d.ts

@@ -0,0 +1,487 @@
+/**
+ * Safe Parsers - Consolidated numeric and type-safe parsing utilities
+ *
+ * Eliminates scattered try/catch patterns for parsing operations across the SDK.
+ * Provides consistent error handling and fallback behavior.
+ *
+ * ## Problem Solved
+ *
+ * Before this module, parsing logic was duplicated with inconsistent patterns:
+ * ```typescript
+ * // Pattern 1: Scattered parseFloat with manual checks
+ * const value = parseFloat(str);
+ * if (isNaN(value)) { throw new Error('Invalid'); }
+ *
+ * // Pattern 2: parseInt with inconsistent radix
+ * const fee = parseInt(feeStr);  // Missing radix!
+ * const fee = parseInt(feeStr, 10);  // Correct
+ *
+ * // Pattern 3: BigNumber with try/catch everywhere
+ * try {
+ *   const bn = new BigNumber(value);
+ *   if (bn.isNaN()) throw new Error('Invalid');
+ * } catch (e) { ... }
+ * ```
+ *
+ * ## Solution
+ *
+ * ```typescript
+ * import { safeParseFloat, safeParseInt, safeParseBigNumber } from './safe-parsers';
+ * import { isNullish } from './validation-helpers';
+ *
+ * const value = safeParseFloat(str, 0);           // Returns 0 on failure
+ * const fee = safeParseInt(feeStr, 3000);         // Returns 3000 on failure
+ * const amount = safeParseBigNumber(val, '0');    // Returns BigNumber('0') on failure
+ * ```
+ *
+ * @category Utilities
+ * @since 6.13.0
+ */
+import BigNumber from 'bignumber.js';
+/**
+ * Result type for parsing operations that may fail
+ */
+export interface ParseResult<T> {
+    success: boolean;
+    value: T;
+    error?: string;
+}
+/**
+ * Safely parse a JSON string with fallback
+ *
+ * Consolidates scattered try/catch JSON.parse patterns across the codebase.
+ * Returns fallback value on parse failure instead of throwing.
+ *
+ * ## Replaces Pattern
+ *
+ * ```typescript
+ * // Before (scattered across codebase)
+ * let data: SomeType;
+ * try {
+ *   data = JSON.parse(jsonString);
+ * } catch {
+ *   data = defaultValue;
+ * }
+ *
+ * // After (single utility)
+ * const data = safeParseJson(jsonString, defaultValue);
+ * ```
+ *
+ * @param value - JSON string to parse
+ * @param fallback - Fallback value if parsing fails
+ * @returns Parsed JSON or fallback value
+ *
+ * @example Basic usage
+ * ```typescript
+ * safeParseJson('{"name": "test"}', {});           // { name: "test" }
+ * safeParseJson('invalid json', {});               // {}
+ * safeParseJson(null, { default: true });          // { default: true }
+ * safeParseJson('{"count": 42}', { count: 0 });    // { count: 42 }
+ * ```
+ *
+ * @example With typed fallback
+ * ```typescript
+ * interface Config { timeout: number; retries: number }
+ * const defaultConfig: Config = { timeout: 5000, retries: 3 };
+ * const config = safeParseJson<Config>(configJson, defaultConfig);
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function safeParseJson<T>(value: string | null | undefined, fallback: T): T;
+/**
+ * Try to parse JSON and return result object
+ *
+ * Use when you need to handle both success and failure cases explicitly
+ * without throwing exceptions.
+ *
+ * @param value - JSON string to parse
+ * @returns ParseResult with success flag, value, and optional error
+ *
+ * @example
+ * ```typescript
+ * const result = tryParseJson('{"valid": true}');
+ * if (result.success) {
+ *   console.log(result.value); // { valid: true }
+ * } else {
+ *   console.log(result.error); // Parse error message
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function tryParseJson<T = unknown>(value: string | null | undefined): ParseResult<T | null>;
+/**
+ * Parse JSON with validation - throws on failure
+ *
+ * Use when you need strict validation and want to throw on invalid JSON.
+ *
+ * @param value - JSON string to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed JSON
+ * @throws ValidationError if value cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const data = parseJsonOrThrow('{"id": 123}', 'config');  // { id: 123 }
+ * const bad = parseJsonOrThrow('invalid', 'config');       // Throws ValidationError
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function parseJsonOrThrow<T = unknown>(value: string | null | undefined, fieldName: string): T;
+/**
+ * Logger interface for numeric parsers that support logging
+ */
+interface ParseLogger {
+    warn(message: string): void;
+    debug?(message: string): void;
+}
+/**
+ * Safely parse a string to float with fallback
+ *
+ * Consolidates scattered parseFloat patterns with proper NaN handling.
+ *
+ * @param value - Value to parse
+ * @param fallback - Fallback value if parsing fails (default: 0)
+ * @returns Parsed float or fallback
+ *
+ * @example
+ * ```typescript
+ * safeParseFloat('123.45');        // 123.45
+ * safeParseFloat('invalid');       // 0
+ * safeParseFloat('invalid', -1);   // -1
+ * safeParseFloat(null, 10);        // 10
+ * safeParseFloat('');              // 0
+ * ```
+ */
+export declare function safeParseFloat(value: string | number | null | undefined, fallback?: number): number;
+/**
+ * Safely parse a string to a number with fallback (alias for safeParseFloat)
+ *
+ * This is a convenience alias that matches the naming convention used in
+ * number-utils.ts. Internally uses safeParseFloat with optional logging.
+ *
+ * @param value - String value to parse
+ * @param fallback - Fallback number if parsing fails
+ * @param logger - Optional logger for warning on invalid input
+ * @returns Valid number
+ *
+ * @example
+ * ```typescript
+ * safeParseNumber('123.45', 0);    // 123.45
+ * safeParseNumber('invalid', 0);  // 0 (silent)
+ * safeParseNumber('invalid', 0, console);  // 0 (logs warning)
+ * ```
+ */
+export declare function safeParseNumber(value: string | number | null | undefined, fallback: number, logger?: ParseLogger): number;
+/**
+ * Safely parse a string to integer with fallback (silent version)
+ *
+ * Always uses radix 10 to prevent parsing issues with leading zeros.
+ *
+ * @param value - Value to parse (string, number, or bigint)
+ * @param fallback - Fallback value if parsing fails (default: 0)
+ * @returns Parsed integer or fallback
+ *
+ * @example
+ * ```typescript
+ * safeParseIntSilent('123');           // 123
+ * safeParseIntSilent('123.99');        // 123 (truncated)
+ * safeParseIntSilent('invalid');       // 0
+ * safeParseIntSilent('3000', 500);     // 3000
+ * safeParseIntSilent(null, 3000);      // 3000
+ * safeParseIntSilent(1234n, 0);        // 1234 (from bigint)
+ * ```
+ */
+export declare function safeParseIntSilent(value: string | number | bigint | null | undefined, fallback?: number): number;
+/**
+ * Safely parse an integer with validation and optional logging
+ *
+ * @param value - String, number, or bigint to parse as integer
+ * @param fallback - Fallback integer if parsing fails
+ * @param logger - Optional logger for warning on invalid input
+ * @returns Valid integer
+ *
+ * @example
+ * ```typescript
+ * safeParseInt('123', 0);           // 123
+ * safeParseInt('123.99', 0);        // 123 (truncated)
+ * safeParseInt('invalid', 0);       // 0 (silent)
+ * safeParseInt('invalid', 0, console);  // 0 (logs warning)
+ * safeParseInt(1234n, 0);           // 1234 (from bigint)
+ * ```
+ */
+export declare function safeParseInt(value: string | number | bigint | null | undefined, fallback: number, logger?: ParseLogger): number;
+/**
+ * Safely parse a value to BigNumber with fallback
+ *
+ * Consolidates BigNumber parsing with proper NaN and error handling.
+ * This is a "safe" parser - errors are silently converted to fallback values.
+ *
+ * **Note:** This function intentionally swallows parsing errors and returns the
+ * fallback value. This is the expected behavior for the "safe" API flavor.
+ * If you need error details, use {@link tryParseBigNumber} which returns
+ * a `ParseResult` with success flag and error message.
+ *
+ * @param value - Value to parse
+ * @param fallback - Fallback value if parsing fails (default: '0')
+ * @returns BigNumber instance (never throws, always returns valid BigNumber)
+ *
+ * @see {@link tryParseBigNumber} - Returns ParseResult with error info
+ * @see {@link parseBigNumberOrThrow} - Throws ValidationError on failure
+ *
+ * @example
+ * ```typescript
+ * safeParseBigNumber('123.456');           // BigNumber(123.456)
+ * safeParseBigNumber('invalid');           // BigNumber(0) - silently falls back
+ * safeParseBigNumber(null, '100');         // BigNumber(100)
+ * safeParseBigNumber('1e10');              // BigNumber(10000000000)
+ * ```
+ */
+export declare function safeParseBigNumber(value: string | number | BigNumber | null | undefined, fallback?: string | number): BigNumber;
+/**
+ * Parse float with validation - throws on failure
+ *
+ * Use when you need strict validation and want to throw on invalid input.
+ *
+ * @param value - Value to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed float
+ * @throws ValidationError if value cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const amount = parseFloatOrThrow('123.45', 'amount');  // 123.45
+ * const bad = parseFloatOrThrow('invalid', 'amount');    // Throws ValidationError
+ * ```
+ */
+export declare function parseFloatOrThrow(value: string | number | null | undefined, fieldName: string): number;
+/**
+ * Parse integer with validation - throws on failure
+ *
+ * Use when you need strict validation and want to throw on invalid input.
+ *
+ * @param value - Value to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed integer
+ * @throws ValidationError if value cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const fee = parseIntOrThrow('3000', 'fee');      // 3000
+ * const bad = parseIntOrThrow('invalid', 'fee');   // Throws ValidationError
+ * ```
+ */
+export declare function parseIntOrThrow(value: string | number | null | undefined, fieldName: string): number;
+/**
+ * Parse BigNumber with validation - throws on failure
+ *
+ * Use when you need strict validation and want to throw on invalid input.
+ *
+ * @param value - Value to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed BigNumber
+ * @throws ValidationError if value cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const amount = parseBigNumberOrThrow('123.456', 'amount');  // BigNumber(123.456)
+ * const bad = parseBigNumberOrThrow('invalid', 'amount');     // Throws ValidationError
+ * ```
+ */
+export declare function parseBigNumberOrThrow(value: string | number | BigNumber | null | undefined, fieldName: string): BigNumber;
+/**
+ * Try to parse float and return result object
+ *
+ * Use when you need to handle both success and failure cases explicitly.
+ *
+ * @param value - Value to parse
+ * @returns ParseResult with success flag, value, and optional error
+ *
+ * @example
+ * ```typescript
+ * const result = tryParseFloat('123.45');
+ * if (result.success) {
+ *   console.log(result.value); // 123.45
+ * } else {
+ *   console.log(result.error); // undefined for valid input
+ * }
+ * ```
+ */
+export declare function tryParseFloat(value: string | number | null | undefined): ParseResult<number>;
+/**
+ * Try to parse integer and return result object
+ *
+ * @param value - Value to parse
+ * @returns ParseResult with success flag, value, and optional error
+ */
+export declare function tryParseInt(value: string | number | null | undefined): ParseResult<number>;
+/**
+ * Try to parse BigNumber and return result object
+ *
+ * @param value - Value to parse
+ * @returns ParseResult with success flag, value, and optional error
+ */
+export declare function tryParseBigNumber(value: string | number | BigNumber | null | undefined): ParseResult<BigNumber>;
+/**
+ * Parse percentage string (removes '%' suffix)
+ *
+ * Handles both "5" and "5%" formats consistently.
+ *
+ * @param value - Value to parse
+ * @param fallback - Fallback value (default: 0)
+ * @returns Parsed percentage as number
+ *
+ * @example
+ * ```typescript
+ * safeParsePercentage('5%');       // 5
+ * safeParsePercentage('5');        // 5
+ * safeParsePercentage('  5.5% ');  // 5.5
+ * safeParsePercentage('invalid');  // 0
+ * ```
+ */
+export declare function safeParsePercentage(value: string | number | null | undefined, fallback?: number): number;
+/**
+ * Parse fee tier string to number
+ *
+ * Fee tiers in Uniswap V3 style pools: 500, 3000, 10000
+ *
+ * @param value - Fee tier value to parse
+ * @param fallback - Fallback value (default: 3000)
+ * @returns Parsed fee tier
+ *
+ * @example
+ * ```typescript
+ * safeParseFeeTier('3000');     // 3000
+ * safeParseFeeTier('0.3%');     // 3000 (converted from percentage)
+ * safeParseFeeTier(10000);      // 10000
+ * safeParseFeeTier('invalid');  // 3000 (fallback)
+ * ```
+ */
+export declare function safeParseFeeTier(value: string | number | null | undefined, fallback?: number): number;
+/**
+ * Parse positive amount with validation
+ *
+ * Specialized parser for token amounts that must be positive.
+ *
+ * @param value - Amount to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed BigNumber
+ * @throws ValidationError if value is not a positive number
+ *
+ * @example
+ * ```typescript
+ * parsePositiveAmount('100', 'amount');    // BigNumber(100)
+ * parsePositiveAmount('0', 'amount');      // Throws: must be positive
+ * parsePositiveAmount('-5', 'amount');     // Throws: must be positive
+ * ```
+ */
+export declare function parsePositiveAmount(value: string | number | BigNumber | null | undefined, fieldName: string): BigNumber;
+/**
+ * Parse non-negative amount with validation
+ *
+ * Specialized parser for amounts that can be zero but not negative.
+ *
+ * @param value - Amount to parse
+ * @param fieldName - Field name for error message
+ * @returns Parsed BigNumber
+ * @throws ValidationError if value is negative
+ *
+ * @example
+ * ```typescript
+ * parseNonNegativeAmount('100', 'fee');    // BigNumber(100)
+ * parseNonNegativeAmount('0', 'fee');      // BigNumber(0)
+ * parseNonNegativeAmount('-5', 'fee');     // Throws: must be non-negative
+ * ```
+ */
+export declare function parseNonNegativeAmount(value: string | number | BigNumber | null | undefined, fieldName: string): BigNumber;
+/**
+ * Validate if a value can be safely converted to a number
+ *
+ * @param value - Value to validate
+ * @returns True if the value can be converted to a valid number
+ *
+ * @example
+ * ```typescript
+ * isValidNumberString('123.45');  // true
+ * isValidNumberString('invalid'); // false
+ * isValidNumberString(42);        // true
+ * isValidNumberString(NaN);       // false
+ * ```
+ */
+export declare function isValidNumberString(value: string | number | null | undefined): boolean;
+/**
+ * Parse number with validation and detailed error context
+ *
+ * @param value - Value to parse
+ * @param context - Context information for debugging (e.g., 'pagination.page')
+ * @param fallback - Fallback number if parsing fails
+ * @param logger - Optional logger for warning on invalid input
+ * @returns Valid number with debug information
+ *
+ * @example
+ * ```typescript
+ * safeParseWithContext('123.45', 'api.amount', 0);  // 123.45
+ * safeParseWithContext(null, 'trade.amount', 100);  // 100
+ * safeParseWithContext('invalid', 'token.qty', 0);  // 0
+ * ```
+ */
+export declare function safeParseWithContext(value: string | number | null | undefined, context: string, fallback: number, logger?: ParseLogger): number;
+/**
+ * Format a number string for DTO validation with specified decimal precision limit
+ *
+ * This prevents DTO validation errors caused by excessive floating-point precision
+ * and ensures numbers are in the correct format (fixed notation, no trailing zeros).
+ *
+ * @param num - Number string to format
+ * @param decimals - Maximum decimal places (default: 18 for launchpad tokens)
+ * @returns Formatted string with maximum specified decimal places
+ *
+ * @example
+ * ```typescript
+ * // GALA transactions (8 decimals max)
+ * formatForDTO('100.123456789', 8) // '100.12345679'
+ *
+ * // Launchpad tokens (18 decimals max)
+ * formatForDTO('0.000000000000000123', 18) // '0.000000000000000123'
+ *
+ * // Default uses launchpad token precision
+ * formatForDTO('123.456') // '123.456'
+ * ```
+ */
+export declare function formatForDTO(num: string, decimals?: number): string;
+/**
+ * Format a GALA amount for DTO validation (8 decimal limit)
+ *
+ * GALA tokens use 8 decimal places on GalaChain. Transactions with more
+ * than 8 decimals will fail, so this function enforces the limit.
+ *
+ * @param num - GALA amount as string
+ * @returns Formatted string with maximum 8 decimal places
+ *
+ * @example
+ * ```typescript
+ * formatGalaForDTO('100.123456789') // '100.12345679'
+ * formatGalaForDTO('0.00000001') // '0.00000001'
+ * ```
+ */
+export declare function formatGalaForDTO(num: string): string;
+/**
+ * Format a launchpad token amount for DTO validation (18 decimal limit)
+ *
+ * Launchpad tokens use 18 decimal places following ERC-20 standard.
+ * This function ensures full precision is maintained for token amounts.
+ *
+ * @param num - Token amount as string
+ * @returns Formatted string with maximum 18 decimal places
+ *
+ * @example
+ * ```typescript
+ * formatLaunchpadTokenForDTO('1000.123456789012345678') // '1000.123456789012345678'
+ * formatLaunchpadTokenForDTO('0.000000000000000001') // '0.000000000000000001'
+ * ```
+ */
+export declare function formatLaunchpadTokenForDTO(num: string): string;
+export {};
+//# sourceMappingURL=safe-parsers.d.ts.map

package/dist/src/utils/safe-parsers.d.ts.map

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