@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.1

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

@@ -1,463 +0,0 @@
-/**
- * Error Handling Utilities
- *
- * Type-safe utilities for handling unknown errors in catch blocks.
- * Replaces unsafe `error: unknown` patterns with `error: unknown` + type guards.
- *
- * @category Utilities
- * @since 3.12.0
- */
-/**
- * Type guard to check if an unknown value is an Error instance
- *
- * @param error Unknown error value from catch block
- * @returns True if error is an Error instance with message and stack
- *
- * @example
- * ```typescript
- * try {
- *   await riskyOperation();
- * } catch (error: unknown) {
- *   if (isError(error)) {
- *     console.log(error.message); // TypeScript knows error.message exists
- *   }
- * }
- * ```
- */
-export declare function isError(error: unknown): error is Error;
-/**
- * Type guard to check if an unknown value has a message property
- *
- * Useful for API errors or custom error objects that may not extend Error
- * but still have a message property.
- *
- * @param error Unknown error value
- * @returns True if error is an object with a string message property
- *
- * @example
- * ```typescript
- * try {
- *   await apiCall();
- * } catch (error: unknown) {
- *   if (hasMessage(error)) {
- *     console.log(error.message); // Works for API errors too
- *   }
- * }
- * ```
- */
-export declare function hasMessage(error: unknown): error is {
-    message: string;
-};
-/**
- * Type guard to check if an unknown value has a code property
- *
- * Useful for errors with error codes (like HTTP status codes, SDK error codes, etc.)
- *
- * @param error Unknown error value
- * @returns True if error is an object with a string or number code property
- *
- * @example
- * ```typescript
- * try {
- *   await httpCall();
- * } catch (error: unknown) {
- *   if (hasCode(error)) {
- *     console.log(`Error code: ${error.code}`);
- *   }
- * }
- * ```
- */
-export declare function hasCode(error: unknown): error is {
-    code: string | number;
-};
-/**
- * Safely extracts error message from unknown error
- *
- * Handles multiple error formats:
- * - Error instances (error.message)
- * - Objects with message property ({ message: "..." })
- * - String errors ("error message")
- * - Other types (converted to string)
- *
- * @param error Unknown error value from catch block
- * @returns Safe string representation of the error
- *
- * @example
- * ```typescript
- * try {
- *   await operation();
- * } catch (error: unknown) {
- *   const message = getErrorMessage(error);
- *   logger.error('Operation failed', message); // Always safe
- * }
- * ```
- */
-export declare function getErrorMessage(error: unknown): string;
-type TradeErrorContext = 'pool' | 'position';
-/** Map defi-backend trade endpoint failures to the SDK's established error classes. */
-export declare function mapTradeBackendError(error: unknown, context: TradeErrorContext): Error;
-/**
- * Safely extracts error stack trace from unknown error
- *
- * @param error Unknown error value from catch block
- * @returns Stack trace string if available, undefined otherwise
- *
- * @example
- * ```typescript
- * try {
- *   await operation();
- * } catch (error: unknown) {
- *   const stack = getErrorStack(error);
- *   if (stack) {
- *     logger.debug('Stack trace:', stack);
- *   }
- * }
- * ```
- */
-export declare function getErrorStack(error: unknown): string | undefined;
-/**
- * Safely extracts error code from unknown error
- *
- * @param error Unknown error value from catch block
- * @returns Error code (string or number) if available, undefined otherwise
- *
- * @example
- * ```typescript
- * try {
- *   await apiCall();
- * } catch (error: unknown) {
- *   const code = getErrorCode(error);
- *   if (code === 404) {
- *     console.log('Resource not found');
- *   }
- * }
- * ```
- */
-export declare function getErrorCode(error: unknown): string | number | undefined;
-/**
- * Formats unknown error into a consistent error object
- *
- * Normalizes different error formats into a standard structure with
- * message, code (if available), and stack (if available).
- *
- * @param error Unknown error value from catch block
- * @returns Normalized error object with consistent structure
- *
- * @example
- * ```typescript
- * try {
- *   await operation();
- * } catch (error: unknown) {
- *   const normalized = normalizeError(error);
- *   console.log(normalized);
- *   // { message: "...", code?: "...", stack?: "..." }
- * }
- * ```
- */
-export declare function normalizeError(error: unknown): {
-    message: string;
-    code?: string | number;
-    stack?: string;
-};
-/**
- * Type guard to check if an unknown value is an axios error
- *
- * Axios errors have specific properties like response, request, config.
- * This helps identify HTTP errors from the axios library.
- *
- * @param error Unknown error value
- * @returns True if error is an axios error with response property
- *
- * @example
- * ```typescript
- * try {
- *   await http.get('/api/endpoint');
- * } catch (error: unknown) {
- *   if (isAxiosError(error)) {
- *     console.log(`HTTP ${error.response?.status}: ${error.message}`);
- *   }
- * }
- * ```
- */
-export declare function isAxiosError(error: unknown): error is {
-    message: string;
-    response?: {
-        status: number;
-        data: unknown;
-        statusText: string;
-        headers?: Record<string, unknown>;
-    };
-    request?: unknown;
-    config?: unknown;
-};
-/**
- * Extracts HTTP status code from axios error
- *
- * @param error Unknown error value (should be axios error)
- * @returns HTTP status code if available, undefined otherwise
- *
- * @example
- * ```typescript
- * try {
- *   await http.post('/api/trade');
- * } catch (error: unknown) {
- *   const status = getHttpStatusCode(error);
- *   if (status === 429) {
- *     console.log('Rate limited');
- *   }
- * }
- * ```
- */
-export declare function getHttpStatusCode(error: unknown): number | undefined;
-/**
- * Validates and extracts response.data with comprehensive null/structure checks
- *
- * Performs combined validation of response object and extraction of its data property.
- * Throws descriptive errors if response is invalid or missing data.
- *
- * @param response Unknown response object from API call
- * @param operation Name of the operation for error messages
- * @returns The data from response.data, strongly typed
- * @throws Error if response is invalid or data is missing
- *
- * @example
- * ```typescript
- * try {
- *   const response = await api.get('/data');
- *   const data = validateAndExtractResponseData<UserData>(response, 'Fetch user');
- *   console.log(data.id); // TypeScript knows data is UserData
- * } catch (error: unknown) {
- *   console.error('Failed to fetch user:', getErrorMessage(error));
- * }
- * ```
- */
-export declare function validateAndExtractResponseData<T>(response: unknown, operation: string): T;
-/**
- * Wraps an error with operation context and message prefix for better error tracing
- *
- * Creates a new Error with a prefixed message that includes the operation context,
- * preserving the original error information through the message.
- *
- * @param error Unknown error to wrap
- * @param context Operation context string (e.g., "Swap delta calculation")
- * @param prefix Optional custom prefix (defaults to context)
- * @returns New Error with context-prefixed message
- *
- * @example
- * ```typescript
- * try {
- *   const result = await performSwap();
- *   return result;
- * } catch (error: unknown) {
- *   throw wrapErrorWithContext(error, 'Swap calculation');
- *   // Throws: "Swap calculation: Original error message"
- * }
- * ```
- */
-export declare function wrapErrorWithContext(error: unknown, context: string, prefix?: string): Error;
-/**
- * Validates response status and throws standardized error if response indicates failure
- *
- * Checks that response exists and has a Status property equal to 1 (success).
- * Throws descriptive errors if response is invalid or indicates failure.
- *
- * @param response Unknown response object from API call
- * @param operation Name of the operation for error messages
- * @returns The response object if status check passes, strongly typed
- * @throws Error if response is invalid or Status is not 1
- *
- * @example
- * ```typescript
- * try {
- *   const response = await this.http.post('/api/data');
- *   const validated = assertResponseSuccess(response, 'API request');
- *   console.log(validated); // TypeScript knows response is valid
- * } catch (error: unknown) {
- *   console.error('API call failed:', getErrorMessage(error));
- * }
- * ```
- */
-export declare function assertResponseSuccess(response: unknown, operation: string): Record<string, unknown>;
-/**
- * Safely extracts error details from HTTP error responses with fallbacks
- *
- * Use this to extract status codes, messages, and error data from axios or HTTP errors.
- * Provides sensible defaults when properties are missing or malformed.
- *
- * @param error The error object to extract details from
- * @returns Object with status, message, and optional data properties
- *
- * @example
- * ```typescript
- * try {
- *   const response = await api.get('/data');
- * } catch (error: unknown) {
- *   const { status, message, data } = extractErrorResponse(error);
- *   console.log(`HTTP ${status}: ${message}`);
- *   if (data) {
- *     console.log('Error details:', data);
- *   }
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Handles various error types gracefully
- * const { status, message } = extractErrorResponse('string error');
- * // → { status: 500, message: "string error", data: undefined }
- *
- * const { status, message } = extractErrorResponse(new Error('Network error'));
- * // → { status: 500, message: "Network error", data: undefined }
- *
- * const { status, message, data } = extractErrorResponse(axiosError);
- * // → { status: 404, message: "Not Found", data: { details: "..." } }
- * ```
- *
- * @since 3.50.0
- */
-export declare function extractErrorResponse(error: unknown): {
-    status: number;
-    message: string;
-    data?: unknown;
-};
-/**
- * Extract error message from response object with optional context
- *
- * Safely extracts Message property from API response for error context
- * without unsafe type casts or verbose inline conditionals.
- *
- * @param response Unknown response object
- * @returns Error message suffix (empty string if no message found)
- *
- * @example
- * ```typescript
- * try {
- *   const result = await sdk.lockTokens(data);
- * } catch (error) {
- *   const responseMsg = extractResponseMessage(response);
- *   throw new LockError(`${getErrorMessage(error)}${responseMsg}`);
- * }
- * ```
- */
-export declare function extractResponseMessage(response: unknown): string;
-/**
- * Collects ValidationError messages from a function into an error array for batch validation reporting
- *
- * Simplifies the pattern of throwing validation errors in try-catch blocks and collecting messages.
- * Catches ValidationError specifically and adds the message to the errors array, re-throws non-ValidationError exceptions.
- *
- * ## Replaces Pattern
- *
- * ### Before (Verbose try-catch for each validation):
- * ```typescript
- * const errors: string[] = [];
- *
- * try {
- *   throw createRequiredFieldError('role', 'Role');
- * } catch (e) {
- *   if (e instanceof ValidationError) errors.push(e.message);
- * }
- *
- * try {
- *   validateLaunchpadTokenName(options.tokenName ?? '', 'tokenName');
- * } catch (e) {
- *   if (e instanceof ValidationError) errors.push(e.message);
- * }
- *
- * try {
- *   throw createInvalidFormatError('address', 'valid Ethereum address');
- * } catch (e) {
- *   if (e instanceof ValidationError) errors.push(e.message);
- * }
- * ```
- *
- * ### After (Concise with collectValidationErrors):
- * ```typescript
- * const errors: string[] = [];
- *
- * collectValidationErrors(errors, () => {
- *   throw createRequiredFieldError('role', 'Role');
- * });
- *
- * collectValidationErrors(errors, () =>
- *   validateLaunchpadTokenName(options.tokenName ?? '', 'tokenName')
- * );
- *
- * collectValidationErrors(errors, () => {
- *   throw createInvalidFormatError('address', 'valid Ethereum address');
- * });
- * ```
- *
- * @param errors Array to accumulate error messages into
- * @param fn Function that may throw ValidationError
- * @param errorPrefix Optional prefix to add to collected error messages for context
- * @throws Non-ValidationError exceptions are re-thrown as-is
- *
- * @example Basic usage with error factory
- * ```typescript
- * const errors: string[] = [];
- *
- * collectValidationErrors(errors, () => {
- *   throw createRequiredFieldError('tokenName');
- * });
- *
- * // errors is now: ['TokenName is required']
- * ```
- *
- * @example With validation helper function
- * ```typescript
- * const errors: string[] = [];
- *
- * collectValidationErrors(errors, () =>
- *   validateLaunchpadTokenName(tokenName, 'tokenName')
- * );
- *
- * if (errors.length > 0) {
- *   throw new ValidationError(errors.join('; '));
- * }
- * ```
- *
- * @example With optional error prefix for context
- * ```typescript
- * const errors: string[] = [];
- *
- * collectValidationErrors(
- *   errors,
- *   () => validateSwapAmount(amount),
- *   'Swap validation failed: '
- * );
- *
- * // If ValidationError thrown, message includes prefix
- * // errors: ['Swap validation failed: Amount must be positive']
- * ```
- *
- * @example Multiple validations with batch reporting
- * ```typescript
- * const errors: string[] = [];
- *
- * collectValidationErrors(errors, () => {
- *   if (!role) throw createRequiredFieldError('role', 'Role');
- * });
- *
- * collectValidationErrors(errors, () => {
- *   if (!isValidEnum(scope)) throw createInvalidEnumError('scope', scope, SCOPES);
- * });
- *
- * collectValidationErrors(errors, () => {
- *   if (description.length > 255) throw createStringTooLongError('description', 255);
- * });
- *
- * if (errors.length > 0) {
- *   throw new ValidationError(
- *     `Validation failed: ${errors.join('; ')}`,
- *     'batch',
- *     'VALIDATION_BATCH_FAILED'
- *   );
- * }
- * ```
- *
- * @since 6.15.0
- */
-export declare function collectValidationErrors(errors: string[], fn: () => void, errorPrefix?: string): void;
-export {};
-//# sourceMappingURL=error-utils.d.ts.map

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

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

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

@@ -1,208 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}