@gala-chain/launchpad-sdk 3.5.3 → 3.6.1

package/dist/services/TradeService.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Trade Service
+ *
+ * Handles all trade-related operations including trade history queries.
+ *
+ * @category Services
+ * @since 3.6.0
+ */
+import { HttpClient } from '../utils/http';
+import { TradesResult } from '../types/trade.dto';
+import { FetchTradesOptions } from '../types/options.dto';
+/**
+ * Trade Service Class
+ *
+ * Provides methods for:
+ * - Fetching trade history with pagination
+ * - Filtering trades by token, user, type, date range
+ *
+ * @example
+ * ```typescript
+ * const tradeService = new TradeService(httpClient);
+ *
+ * // Get first page of trades for a token
+ * const trades = await tradeService.fetchTrades({ tokenName: "dragnrkti" });
+ *
+ * // Get specific page with custom limit
+ * const moreTrades = await tradeService.fetchTrades({
+ *   tokenName: "dragnrkti",
+ *   page: 2,
+ *   limit: 20
+ * });
+ * ```
+ */
+export declare class TradeService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Gets trades for a token by its tokenName with pagination
+     *
+     * This method provides a clean, intuitive API for fetching token trades
+     * using the token name. Follows the same pattern as CommentAPI.
+     *
+     * @param options Trade fetching options
+     * @returns Promise<TradesResult> Clean trades with full pagination
+     * @throws ValidationError if token name is invalid or not found
+     */
+    fetchTrades(options: FetchTradesOptions): Promise<TradesResult>;
+    /**
+     * Validates pagination parameters
+     *
+     * @private
+     */
+    private validateTradePagination;
+}
+//# sourceMappingURL=TradeService.d.ts.map

package/dist/services/TradeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TradeService.d.ts","sourceRoot":"","sources":["../../src/services/TradeService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,OAAO,EAEL,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAwB,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;OASG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IA2DrE;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;CAyBhC"}

package/dist/services/UserService.d.ts

@@ -0,0 +1,121 @@
+/**
+ * User Service
+ *
+ * Handles all user-related operations including profile management,
+ * token lists, and user data queries.
+ *
+ * @category Services
+ * @since 3.6.0
+ */
+import { HttpClient } from '../utils/http';
+import { GetTokenListOptions, UserTokenListResult, UpdateProfileData, UploadProfileImageOptions } from '../types/user.dto';
+/**
+ * User Service Class
+ *
+ * Provides methods for:
+ * - Profile management (fetch, update)
+ * - Profile image uploads
+ * - Token list queries (created, held)
+ *
+ * @example
+ * ```typescript
+ * const userService = new UserService(httpClient);
+ *
+ * // Get user profile
+ * const profile = await userService.fetchProfile();
+ *
+ * // Update profile
+ * await userService.updateProfile({
+ *   profileImage: "https://example.com/avatar.jpg",
+ *   fullName: "John Doe",
+ *   address: "eth|1234..."
+ * });
+ * ```
+ */
+export declare class UserService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetches user profile information
+     *
+     * @param address Optional wallet address (defaults to SDK wallet address)
+     * @returns Promise<any> User profile information
+     * @throws ValidationError if input validation fails
+     */
+    fetchProfile(address?: string): Promise<any>;
+    /**
+     * Updates user profile information
+     *
+     * **Smart Image Preservation**: If profileImage is empty or not provided,
+     * the method automatically fetches and preserves the existing profile image
+     * to prevent accidental image loss.
+     *
+     * @param data Profile update data
+     * @returns Promise<void> No return data - throws on failure
+     * @throws ValidationError if input validation fails
+     * @throws Error if profile update fails
+     */
+    updateProfile(data: UpdateProfileData): Promise<void>;
+    /**
+     * Uploads a profile image and returns the image URL
+     *
+     * @param options Profile image upload options
+     * @returns Promise<string> Clean image URL
+     * @throws ValidationError if input validation fails
+     * @throws Error if upload fails
+     */
+    uploadProfileImage(options: UploadProfileImageOptions): Promise<string>;
+    /**
+     * Fetches user token list with optional filtering and pagination
+     *
+     * @param options Filtering and pagination options
+     * @returns Promise<UserTokenListResult> Clean token list with proper types
+     * @throws Error if request fails
+     */
+    fetchTokenList(options: GetTokenListOptions): Promise<UserTokenListResult>;
+    /**
+     * Fetches tokens held by user (balances)
+     *
+     * @param options Token held filtering options (address is optional)
+     * @returns Promise<UserTokenListResult> Clean tokens held with full pagination
+     * @throws ValidationError if input validation fails
+     */
+    fetchTokensHeld(options: GetTokenListOptions): Promise<UserTokenListResult>;
+    /**
+     * Fetches tokens created by user
+     *
+     * @param options Options including pagination
+     * @returns Promise<UserTokenListResult> Tokens created by the user
+     */
+    fetchTokensCreated(options?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+        tokenName?: string;
+    }): Promise<UserTokenListResult>;
+    /**
+     * Validates get token list options
+     *
+     * @private
+     */
+    private validateGetTokenListOptions;
+    /**
+     * Validates user pagination parameters
+     *
+     * @private
+     */
+    private validateUserPagination;
+    /**
+     * Validates update profile data
+     *
+     * @private
+     */
+    private validateUpdateProfileData;
+    /**
+     * Validates upload profile image options
+     *
+     * @private
+     */
+    private validateUploadProfileImageOptions;
+}
+//# sourceMappingURL=UserService.d.ts.map

package/dist/services/UserService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserService.d.ts","sourceRoot":"","sources":["../../src/services/UserService.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAM3C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EAEjB,yBAAyB,EAO1B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;OAMG;IACG,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAmBlD;;;;;;;;;;;OAWG;IACG,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiD3D;;;;;;;OAOG;IACG,kBAAkB,CACtB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,MAAM,CAAC;IAgElB;;;;;;OAMG;IACG,cAAc,CAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC;IA0C/B;;;;;;OAMG;IACG,eAAe,CACnB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC;IAyC/B;;;;;OAKG;IACG,kBAAkB,CACtB,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO,GACnF,OAAO,CAAC,mBAAmB,CAAC;IAsB/B;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAuCnC;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IA0B9B;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAkBjC;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;CAW1C"}

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

@@ -0,0 +1,95 @@
+/**
+ * Error Factories
+ *
+ * Standardized error message generators for common validation failures.
+ * Eliminates duplicate error messages across services.
+ *
+ * @category Utilities
+ * @since 3.6.1
+ */
+import { ValidationError } from './validation';
+/**
+ * Creates a standardized "token not found" validation error
+ *
+ * This factory eliminates duplicate token error messages found across
+ * multiple service files. It provides a single source of truth for
+ * token resolution failures.
+ *
+ * ## Replaces Patterns
+ *
+ * This function replaces 8+ instances of duplicate error creation:
+ *
+ * ### Before (Duplicate Pattern Across Services):
+ * ```typescript
+ * // CommentService.ts (×2)
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // BundleService.ts (×2)
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // GalaChainService.ts
+ * throw new ValidationError(
+ *   `Token '${tokenName}' not found or not available for transfer`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // TokenResolverService.ts
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ * ```
+ *
+ * ### After (Single Source of Truth):
+ * ```typescript
+ * // CommentService.ts
+ * throw createTokenNotFoundError(tokenName);
+ *
+ * // BundleService.ts
+ * throw createTokenNotFoundError(tokenName);
+ *
+ * // GalaChainService.ts
+ * throw createTokenNotFoundError(tokenName, 'transfer');
+ *
+ * // TokenResolverService.ts
+ * throw createTokenNotFoundError(tokenName);
+ * ```
+ *
+ * @param tokenName The token name that was not found
+ * @param context Optional context for error message customization
+ * @returns ValidationError with standardized message
+ *
+ * @example Basic usage
+ * ```typescript
+ * const tokenName = 'mytoken';
+ * const vaultAddress = await resolveTokenName(tokenName);
+ * if (!vaultAddress) {
+ *   throw createTokenNotFoundError(tokenName);
+ * }
+ * // Throws: ValidationError with message:
+ * // "Token "mytoken" not found. Please verify the token name is correct."
+ * ```
+ *
+ * @example With transfer context
+ * ```typescript
+ * const tokenName = 'mytoken';
+ * const tokenInfo = await getTokenForTransfer(tokenName);
+ * if (!tokenInfo) {
+ *   throw createTokenNotFoundError(tokenName, 'transfer');
+ * }
+ * // Throws: ValidationError with message:
+ * // "Token 'mytoken' not found or not available for transfer"
+ * ```
+ */
+export declare function createTokenNotFoundError(tokenName: string, context?: 'transfer'): ValidationError;
+//# sourceMappingURL=error-factories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-factories.d.ts","sourceRoot":"","sources":["../../src/utils/error-factories.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,UAAU,GACnB,eAAe,CAOjB"}

package/dist/utils/query-params.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Query Parameter Building Utilities
+ *
+ * Unified utilities for building backend query parameters.
+ * Replaces multiple duplicate query building methods with a single,
+ * type-safe, reusable utility.
+ *
+ * @category Utilities
+ * @since 3.6.0
+ */
+/**
+ * Configuration for field transformations
+ */
+export interface QueryParamConfig<T> {
+    /** Fields that should be converted to strings */
+    stringifyFields?: (keyof T)[];
+    /** Fields that should be excluded if undefined/empty */
+    optionalFields?: (keyof T)[];
+    /** Custom field name mappings (source -> backend) */
+    fieldMappings?: Partial<Record<keyof T, string>>;
+}
+/**
+ * Builds backend query parameters from typed options object
+ *
+ * This utility consolidates the logic from multiple query building methods:
+ * - buildGetCommentsQueryParams
+ * - buildTradeQueryParams
+ * - buildTokenListQueryParams
+ * - buildTokenHoldQueryParams
+ *
+ * @template T The type of the input options object
+ * @param options Input options to convert to query parameters
+ * @param config Configuration for field transformations
+ * @returns Query parameters ready for backend API
+ *
+ * @example
+ * ```typescript
+ * // Simple pagination
+ * const params = buildBackendQueryParams(
+ *   { page: 1, limit: 10 },
+ *   { stringifyFields: ['page', 'limit'] }
+ * );
+ * // Result: { page: '1', limit: '10' }
+ *
+ * // With optional fields
+ * const params = buildBackendQueryParams(
+ *   { page: 1, limit: 10, search: 'test', tokenName: undefined },
+ *   {
+ *     stringifyFields: ['page', 'limit'],
+ *     optionalFields: ['search', 'tokenName']
+ *   }
+ * );
+ * // Result: { page: '1', limit: '10', search: 'test' }
+ *
+ * // With field mappings
+ * const params = buildBackendQueryParams(
+ *   { walletAddress: 'eth|123', amount: '100' },
+ *   { fieldMappings: { walletAddress: 'userAddress' } }
+ * );
+ * // Result: { userAddress: 'eth|123', amount: '100' }
+ * ```
+ */
+export declare function buildBackendQueryParams<T extends Record<string, any>>(options: T, config?: QueryParamConfig<T>): Record<string, any>;
+/**
+ * Builds pagination query parameters (common pattern)
+ *
+ * Convenience function for the most common use case: pagination with page/limit.
+ *
+ * @param page Page number
+ * @param limit Items per page
+ * @returns Query parameters with stringified page and limit
+ *
+ * @example
+ * ```typescript
+ * const params = buildPaginationParams(2, 20);
+ * // Result: { page: '2', limit: '20' }
+ * ```
+ */
+export declare function buildPaginationParams(page: number, limit: number): Record<string, string>;
+/**
+ * Builds token query parameters with pagination
+ *
+ * Common pattern for token-related endpoints that support
+ * pagination plus optional filters.
+ *
+ * @param tokenName Token name to query
+ * @param page Page number
+ * @param limit Items per page
+ * @returns Query parameters ready for backend API
+ *
+ * @example
+ * ```typescript
+ * const params = buildTokenQueryParams('mytoken', 1, 10);
+ * // Result: { tokenName: 'mytoken', page: '1', limit: '10' }
+ * ```
+ */
+export declare function buildTokenQueryParams(tokenName: string, page: number, limit: number): Record<string, any>;
+//# sourceMappingURL=query-params.d.ts.map

package/dist/utils/query-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.d.ts","sourceRoot":"","sources":["../../src/utils/query-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,iDAAiD;IACjD,eAAe,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9B,wDAAwD;IACxD,cAAc,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC7B,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnE,OAAO,EAAE,CAAC,EACV,MAAM,GAAE,gBAAgB,CAAC,CAAC,CAAM,GAC/B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyCrB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAKrB"}

package/dist/utils/response-handlers.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Response Handlers
+ *
+ * Standardized response validation and error handling for API calls.
+ * Eliminates duplicate error checking patterns across services.
+ *
+ * @category Utilities
+ * @since 3.6.1
+ */
+/**
+ * Standard backend response structure
+ */
+interface BackendResponse<T = unknown> {
+    status: number;
+    error: boolean;
+    message?: string;
+    data?: T;
+}
+/**
+ * Asserts that a backend response is successful, throwing an error if not.
+ *
+ * This utility eliminates the duplicate error checking pattern found across
+ * all service files. It provides a single source of truth for response validation.
+ *
+ * ## Error Checking Logic
+ *
+ * A response is considered **failed** if any of these conditions are true:
+ * 1. `response.error === true` - Explicit error flag from backend
+ * 2. `response.status !== 200` - Non-success HTTP status code
+ * 3. `requireData === true && !response.data` - Data is required but missing
+ *
+ * ## Replaces Patterns
+ *
+ * This function replaces 18+ instances of duplicate error checking:
+ *
+ * ### Before (Duplicate Pattern in Every Service):
+ * ```typescript
+ * // PoolService.ts
+ * if (response.error === true || response.status !== 200 || !response.data) {
+ *   throw new Error(response.message || 'Failed to fetch pools');
+ * }
+ *
+ * // CommentService.ts
+ * if (response.error) {
+ *   throw new Error(response.message || 'Failed to post comment');
+ * }
+ *
+ * // FaucetService.ts
+ * if (response.error || response.status !== 200) {
+ *   throw new Error(response.message || 'Faucet transfer failed');
+ * }
+ *
+ * // ... 15 more duplicate instances across different services
+ * ```
+ *
+ * ### After (Single Source of Truth):
+ * ```typescript
+ * // PoolService.ts
+ * assertResponseSuccess(response, 'Failed to fetch pools', true);
+ *
+ * // CommentService.ts
+ * assertResponseSuccess(response, 'Failed to post comment');
+ *
+ * // FaucetService.ts
+ * assertResponseSuccess(response, 'Faucet transfer failed');
+ *
+ * // All services use the same consistent error handling
+ * ```
+ *
+ * @template T The expected type of response.data
+ * @param response Backend response object to validate
+ * @param defaultErrorMessage Default error message if response.message is unavailable
+ * @param requireData Whether to require response.data to be present (default: false)
+ * @throws Error if the response indicates failure
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - check status and error flag only
+ * const response = await http.post('/api/endpoint', data);
+ * assertResponseSuccess(response, 'Operation failed');
+ * // No return value - throws if response is invalid
+ *
+ * // Require data to be present
+ * const response = await http.get('/api/pools');
+ * assertResponseSuccess(response, 'Failed to fetch pools', true);
+ * // Throws if response.error, status !== 200, OR !response.data
+ *
+ * // Custom error message context
+ * assertResponseSuccess(response, 'Token creation failed');
+ * assertResponseSuccess(response, 'Profile update failed');
+ * assertResponseSuccess(response, 'Comment submission failed');
+ * ```
+ */
+export declare function assertResponseSuccess<T = unknown>(response: BackendResponse<T>, defaultErrorMessage: string, requireData?: boolean): void;
+export {};
+//# sourceMappingURL=response-handlers.d.ts.map

package/dist/utils/response-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-handlers.d.ts","sourceRoot":"","sources":["../../src/utils/response-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,UAAU,eAAe,CAAC,CAAC,GAAG,OAAO;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;CACV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAC/C,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,EAC5B,mBAAmB,EAAE,MAAM,EAC3B,WAAW,GAAE,OAAe,GAC3B,IAAI,CAQN"}

package/dist/utils/response-normalizers.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Response Normalization Utilities
+ *
+ * Utilities for normalizing backend API responses into consistent formats.
+ * Handles the various response structure variations from the backend API,
+ * reducing complexity in service methods.
+ *
+ * @category Utilities
+ * @since 3.6.0
+ */
+/**
+ * Normalizes pool response data into consistent array format
+ *
+ * The backend API returns pools in different formats depending on the query:
+ * - Single token: { tokens: {pool data} }
+ * - Multiple tokens: { tokens: [{pool data}] }
+ * - Legacy format: { pools: [{pool data}] }
+ *
+ * This normalizer ensures we always get an array of pools with proper Date objects.
+ *
+ * @param data Raw response data from backend
+ * @returns Normalized array of pools with Date objects
+ *
+ * @example
+ * ```typescript
+ * // Single token response
+ * const normalized = normalizePoolResponse({
+ *   tokens: { id: 1, created_at: '2024-01-01' }
+ * });
+ * // Result: [{ id: 1, createdAt: Date('2024-01-01') }]
+ *
+ * // Multiple tokens response
+ * const normalized = normalizePoolResponse({
+ *   tokens: [{ id: 1, created_at: '2024-01-01' }, { id: 2, created_at: '2024-01-02' }]
+ * });
+ * // Result: [{ id: 1, createdAt: Date('2024-01-01') }, { id: 2, createdAt: Date('2024-01-02') }]
+ * ```
+ */
+export declare function normalizePoolResponse(data: any): any[];
+/**
+ * Normalizes trade response data into consistent array format
+ *
+ * The backend API returns trades in different formats:
+ * - Direct array: [trade1, trade2]
+ * - Wrapped object: { trades: [trade1, trade2] }
+ *
+ * This normalizer ensures we always get an array of trades with proper Date objects.
+ *
+ * @param data Raw response data from backend
+ * @returns Normalized array of trades with Date objects
+ *
+ * @example
+ * ```typescript
+ * const normalized = normalizeTradeResponse({
+ *   trades: [
+ *     { id: 1, createdAt: '2024-01-01', updatedAt: '2024-01-01' }
+ *   ]
+ * });
+ * // Result: [{ id: 1, createdAt: Date(...), updatedAt: Date(...) }]
+ * ```
+ */
+export declare function normalizeTradeResponse(data: any): any[];
+/**
+ * Normalizes token list response data into consistent array format
+ *
+ * The backend API returns token lists in different formats:
+ * - Direct array: [token1, token2]
+ * - Wrapped object: { token: [token1, token2] }
+ *
+ * This normalizer ensures we always get an array of tokens with proper Date objects.
+ *
+ * @param data Raw response data from backend
+ * @returns Normalized array of tokens with Date objects
+ *
+ * @example
+ * ```typescript
+ * const normalized = normalizeTokenListResponse({
+ *   token: [
+ *     { id: 1, createdAt: '2024-01-01', updatedAt: '2024-01-01' }
+ *   ]
+ * });
+ * // Result: [{ id: 1, createdAt: Date(...), updatedAt: Date(...) }]
+ * ```
+ */
+export declare function normalizeTokenListResponse(data: any): any[];
+/**
+ * Extracts pagination metadata from backend response
+ *
+ * Safely extracts page, limit, and total from various response formats,
+ * providing defaults when fields are missing.
+ *
+ * @param response Raw backend response
+ * @param defaults Default values for page and limit
+ * @returns Normalized pagination metadata
+ *
+ * @example
+ * ```typescript
+ * const pagination = extractPaginationMetadata(
+ *   { page: '2', limit: '10', total: '100' },
+ *   { page: 1, limit: 10 }
+ * );
+ * // Result: { page: 2, limit: 10, total: 100, totalPages: 10 }
+ * ```
+ */
+export declare function extractPaginationMetadata(response: any, defaults: {
+    page: number;
+    limit: number;
+}): {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+};
+/**
+ * Creates pagination helper flags
+ *
+ * Calculates hasNext and hasPrevious flags based on current page and total pages.
+ *
+ * @param page Current page number
+ * @param totalPages Total number of pages
+ * @returns Pagination navigation flags
+ *
+ * @example
+ * ```typescript
+ * const flags = createPaginationFlags(2, 5);
+ * // Result: { hasNext: true, hasPrevious: true }
+ * ```
+ */
+export declare function createPaginationFlags(page: number, totalPages: number): {
+    hasNext: boolean;
+    hasPrevious: boolean;
+};
+//# sourceMappingURL=response-normalizers.d.ts.map

package/dist/utils/response-normalizers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-normalizers.d.ts","sourceRoot":"","sources":["../../src/utils/response-normalizers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAgCtD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAkBvD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAc3D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,GAAG,EACb,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxC;IACD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAOA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACtB,CAKA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gala-chain/launchpad-sdk",
-  "version": "3.5.3",
+  "version": "3.6.1",
   "description": "TypeScript SDK for Gala Launchpad Backend API - Production-ready DeFi token launchpad integration with wallet-based authentication, GalaChain trading, and comprehensive user operations. 100% tested (22/22 endpoints working).",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",