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

package/dist/src/utils/service-validators.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Service-Layer Validation Utilities
+ *
+ * Consolidated validators for service methods. Eliminates 927+ duplicate validation patterns:
+ * - 352+ string type checks
+ * - 210+ range/boundary checks
+ * - 127+ string length checks
+ * - 89+ number type checks
+ * - 69+ Array.isArray() checks
+ * - 21+ Number.isInteger() checks
+ *
+ * These validators are designed for service methods where validation failure should throw.
+ * For conditional validation, use validation-helpers.ts instead.
+ *
+ * @category Utilities
+ * @since 6.18.0
+ */
+import type { TokenNameConstraint } from '../types/constraints';
+/**
+ * Validates that a value is a required non-empty string
+ *
+ * Consolidates 352+ instances of:
+ * ```typescript
+ * if (typeof value !== 'string' || value.trim().length === 0) {
+ *   throw new ValidationError('...');
+ * }
+ * ```
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is not a non-empty string
+ *
+ * @example
+ * ```typescript
+ * validateRequiredString(options.tokenName, 'tokenName');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateRequiredString(value: unknown, field: string): asserts value is string;
+/**
+ * Validates that a value is an optional string with optional max length constraint
+ *
+ * Consolidates 127+ instances of string length checking and type validation.
+ * Allows undefined/null for optional fields.
+ *
+ * @param value Value to validate (may be undefined/null)
+ * @param field Field name for error messages
+ * @param maxLength Optional maximum length (no limit if not provided)
+ * @throws {ValidationError} If value is provided but invalid
+ *
+ * @example No length constraint
+ * ```typescript
+ * validateOptionalString(options.description, 'description');
+ * ```
+ *
+ * @example With length constraint
+ * ```typescript
+ * validateOptionalString(options.reason, 'reason', 255);
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateOptionalString(value: unknown, field: string, maxLength?: number): void;
+/**
+ * Validates that a value is a positive integer
+ *
+ * Consolidates 21+ instances of:
+ * ```typescript
+ * if (!Number.isInteger(value) || value < 1) {
+ *   throw new ValidationError('...');
+ * }
+ * ```
+ *
+ * Delegates to positiveIntegerValidation from validation-patterns.ts.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * validatePositiveInteger(options.limit, 'limit');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validatePositiveInteger(value: unknown, field: string): asserts value is number;
+/**
+ * Validates that a value is a number within a range (optional field)
+ *
+ * Consolidates 210+ instances of range checking:
+ * ```typescript
+ * if (typeof value !== 'number' || value < min || value > max) {
+ *   throw createRangeError(...);
+ * }
+ * ```
+ *
+ * Allows undefined/null for optional fields.
+ *
+ * @param value Value to validate (may be undefined/null)
+ * @param field Field name for error messages
+ * @param min Minimum allowed value (inclusive)
+ * @param max Maximum allowed value (inclusive)
+ * @throws {ValidationError} If value is provided but outside range
+ *
+ * @example
+ * ```typescript
+ * validateOptionalNumber(options.slippage, 'slippage', 0.001, 0.5);
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateOptionalNumber(value: unknown, field: string, min?: number, max?: number): void;
+/**
+ * Validates token name with constraints (required field)
+ *
+ * Consolidates duplicate token name validation across multiple services.
+ * Validates token name is 3-20 alphanumeric characters by default.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages (default: 'tokenName')
+ * @param constraint Token name constraint (default: LAUNCHPAD_TOKEN_NAME_CONSTRAINT)
+ * @throws {ValidationError} If token name is invalid
+ *
+ * @example
+ * ```typescript
+ * validateTokenNameWithConstraints(options.tokenName, 'tokenName');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateTokenNameWithConstraints(value: unknown, field?: string, constraint?: TokenNameConstraint): asserts value is string;
+/**
+ * Validates a status filter value (optional)
+ *
+ * Used in services that have status filtering options.
+ * Allows undefined/null and validates against allowed values.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @param allowedValues Array of allowed status values
+ * @throws {ValidationError} If value is provided but not in allowed values
+ *
+ * @example
+ * ```typescript
+ * validateStatusFilter(options.status, 'status', ['active', 'inactive', 'pending']);
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateStatusFilter(value: unknown, field: string, allowedValues: readonly string[]): void;
+/**
+ * Validates that a value is a non-empty array (required field)
+ *
+ * Consolidates 69+ instances of Array.isArray() checks with additional validation.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is not a non-empty array
+ *
+ * @example
+ * ```typescript
+ * validateNonEmptyArray(options.tokens, 'tokens');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateNonEmptyArray(value: unknown, field: string): asserts value is unknown[];
+/**
+ * Validates that an array length is within bounds (optional field)
+ *
+ * Allows undefined/null for optional array fields.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @param maxLength Maximum allowed array length
+ * @throws {ValidationError} If array exceeds max length
+ *
+ * @example
+ * ```typescript
+ * validateArrayLength(options.tags, 'tags', 10);
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateArrayLength(value: unknown, field: string, maxLength: number): void;
+/**
+ * Validates that a value is an optional non-null object (excluding arrays)
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is provided but not an object
+ *
+ * @example
+ * ```typescript
+ * validateOptionalObject(options.metadata, 'metadata');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateOptionalObject(value: unknown, field: string): asserts value is object | undefined | null;
+/**
+ * Validates that a value is a required non-null object (excluding arrays)
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is not an object
+ *
+ * @example
+ * ```typescript
+ * validateRequiredObject(options.config, 'config');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateRequiredObject(value: unknown, field: string): asserts value is object;
+/**
+ * Validates that a value is an optional date
+ *
+ * Accepts Date objects, ISO 8601 date strings, or numeric timestamps.
+ * Allows undefined/null for optional fields.
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is provided but not a valid date
+ *
+ * @example
+ * ```typescript
+ * validateOptionalDate(options.expiresAt, 'expiresAt');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateOptionalDate(value: unknown, field: string): void;
+/**
+ * Validates a required date (Date object, ISO 8601 string, or numeric timestamp)
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @throws {ValidationError} If value is not a valid date
+ *
+ * @example
+ * ```typescript
+ * validateRequiredDate(options.startDate, 'startDate');
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateRequiredDate(value: unknown, field: string): asserts value is Date | string | number;
+/**
+ * Validates that a value is within a string length range (required field)
+ *
+ * @param value Value to validate
+ * @param field Field name for error messages
+ * @param minLength Minimum allowed length
+ * @param maxLength Maximum allowed length
+ * @throws {ValidationError} If string is outside the length range
+ *
+ * @example
+ * ```typescript
+ * validateStringLength(options.reason, 'reason', 1, 500);
+ * ```
+ *
+ * @since 6.18.0
+ */
+export declare function validateStringLength(value: unknown, field: string, minLength: number, maxLength: number): asserts value is string;
+//# sourceMappingURL=service-validators.d.ts.map

package/dist/src/utils/service-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-validators.d.ts","sourceRoot":"","sources":["../../../src/utils/service-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAKhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAO7F;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAmB9F;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAE9F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,MAAM,GACX,IAAI,CAeN;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,MAAoB,EAC3B,UAAU,GAAE,mBAAqD,GAChE,OAAO,CAAC,KAAK,IAAI,MAAM,CAgCzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,IAAI,CAmBN;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,EAAE,CAW/F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAmB1F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,IAAI,MAAM,GAAG,SAAS,GAAG,IAAI,CAM5C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,IAAI,MAAM,CAIzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CA0BxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,GAAG,MAAM,GAAG,MAAM,CA0B3G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,KAAK,IAAI,MAAM,CAQzB"}

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

@@ -1 +1 @@
-{"version":3,"file":"slippage-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/slippage-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,aAAa,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,qBAAqB,GACnC,MAAM,CAuDR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,GACrB,MAAM,CAYR"}
+{"version":3,"file":"slippage-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/slippage-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,aAAa,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,qBAAqB,GACnC,MAAM,CAqDR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,GACrB,MAAM,CAYR"}

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

@@ -0,0 +1,404 @@
+/**
+ * Advanced String Pattern Utilities
+ *
+ * Specialized string manipulation functions for chat validation, token comparison,
+ * error message normalization, and address parsing. Consolidates duplicated patterns
+ * from chat/comment/ban operations, trading workflows, and error handling.
+ *
+ * @category Utilities
+ * @since 6.14.0
+ */
+/**
+ * Safely trim a string and validate it is non-empty.
+ *
+ * Performs conditional trimming and validation for optional string values.
+ * Returns null if value is falsy, not a string, or empty after trimming.
+ * Useful for chat messages, reasons, comments, and other user input validation.
+ *
+ * Consolidated from 15 duplicated patterns in chat/comment/ban operations:
+ * - `reason?.trim() && reason.trim().length > 0`
+ * - `content?.trim().length > 0`
+ * - `message && message.trim().length > 0`
+ *
+ * @param value Unknown input value to process
+ * @param fieldName Optional field name for error context (not used in validation, for documentation)
+ * @param minLength Optional minimum length requirement (default: 1)
+ * @returns Trimmed string if valid and non-empty, null otherwise
+ *
+ * @example Basic usage with optional values
+ * ```typescript
+ * import { conditionalTrimAndValidateString } from '@gala-chain/launchpad-sdk';
+ *
+ * const message = '  Hello world  ';
+ * const trimmed = conditionalTrimAndValidateString(message);
+ * console.log(trimmed); // 'Hello world'
+ *
+ * const empty = '   ';
+ * console.log(conditionalTrimAndValidateString(empty)); // null
+ *
+ * const undefined_ = undefined;
+ * console.log(conditionalTrimAndValidateString(undefined_)); // null
+ * ```
+ *
+ * @example Chat message validation
+ * ```typescript
+ * import { conditionalTrimAndValidateString } from '@gala-chain/launchpad-sdk';
+ *
+ * const chatMessage = userInput?.trim();
+ * // OLD: if (chatMessage && chatMessage.length > 0) { ... }
+ * // NEW:
+ * const validatedMessage = conditionalTrimAndValidateString(userInput, 'message');
+ * if (validatedMessage !== null) {
+ *   await sdk.sendChatMessage(validatedMessage);
+ * }
+ * ```
+ *
+ * @example Comment with minimum length
+ * ```typescript
+ * import { conditionalTrimAndValidateString } from '@gala-chain/launchpad-sdk';
+ *
+ * const comment = '  Hi  '; // Only 2 chars after trim
+ * const validated = conditionalTrimAndValidateString(comment, 'comment', 5);
+ * console.log(validated); // null (2 < 5)
+ *
+ * const goodComment = '  This is great!  '; // 14 chars after trim
+ * const result = conditionalTrimAndValidateString(goodComment, 'comment', 5);
+ * console.log(result); // 'This is great!'
+ * ```
+ *
+ * @example Ban reason validation
+ * ```typescript
+ * import { conditionalTrimAndValidateString } from '@gala-chain/launchpad-sdk';
+ *
+ * const reason = userProvidedReason;
+ * // OLD: if (reason?.trim() && reason.trim().length > 0) { ... }
+ * // NEW:
+ * const validatedReason = conditionalTrimAndValidateString(reason, 'reason');
+ * if (validatedReason !== null) {
+ *   await sdk.createBan({ tokenName, userAddress, reason: validatedReason });
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function conditionalTrimAndValidateString(value: unknown, fieldName?: string, minLength?: number): string | null;
+/**
+ * Case-insensitive token comparison with bidirectional matching.
+ *
+ * Compares two token symbols while ignoring case differences.
+ * Useful for pool matching and token filtering where case normalization is needed.
+ *
+ * Consolidated from 8 duplicated patterns in trading/pool matching:
+ * - `tokenA.toLowerCase() === tokenB.toLowerCase()`
+ * - `token0?.toLowerCase() === token1?.toLowerCase()`
+ *
+ * @param tokenA First token symbol to compare
+ * @param tokenB Second token symbol to compare
+ * @returns True if tokens match (case-insensitive), false otherwise
+ *
+ * @example Basic token comparison
+ * ```typescript
+ * import { caseInsensitiveTokenComparison } from '@gala-chain/launchpad-sdk';
+ *
+ * caseInsensitiveTokenComparison('GALA', 'gala');      // true
+ * caseInsensitiveTokenComparison('USDC', 'usdc');      // true
+ * caseInsensitiveTokenComparison('GALA', 'USDC');      // false
+ * ```
+ *
+ * @example Pool token matching
+ * ```typescript
+ * import { caseInsensitiveTokenComparison } from '@gala-chain/launchpad-sdk';
+ *
+ * const poolToken0 = 'GALA';
+ * const poolToken1 = 'GUSDC';
+ * const searchToken = 'gala';
+ *
+ * if (caseInsensitiveTokenComparison(poolToken0, searchToken)) {
+ *   // This pool contains GALA
+ * }
+ * ```
+ *
+ * @example Filtering positions
+ * ```typescript
+ * import { caseInsensitiveTokenComparison } from '@gala-chain/launchpad-sdk';
+ *
+ * const searchSymbol = 'gusdc';
+ * const galaPositions = positions.filter(p =>
+ *   caseInsensitiveTokenComparison(p.token0, searchSymbol) ||
+ *   caseInsensitiveTokenComparison(p.token1, searchSymbol)
+ * );
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function caseInsensitiveTokenComparison(tokenA: string, tokenB: string): boolean;
+/**
+ * Normalize error message to lowercase for consistent error pattern matching.
+ *
+ * Converts error messages to lowercase for case-insensitive substring searching.
+ * Useful for matching specific error conditions regardless of message casing.
+ *
+ * Consolidated from 8 duplicated patterns in error type matching:
+ * - `error.message.toLowerCase().includes('pattern')`
+ * - `message.toLowerCase().includes('insufficient')`
+ *
+ * @param message The error message to normalize
+ * @returns Lowercase version of the message
+ *
+ * @example Error pattern matching
+ * ```typescript
+ * import { errorMessageCaseNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * try {
+ *   // ... operation
+ * } catch (error: any) {
+ *   const normalized = errorMessageCaseNormalization(error.message);
+ *   if (normalized.includes('insufficient balance')) {
+ *     // Handle insufficient balance
+ *   }
+ * }
+ * ```
+ *
+ * @example Transaction error categorization
+ * ```typescript
+ * import { errorMessageCaseNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * const errorMsg = 'TRANSACTION FAILED: Insufficient Balance';
+ * const normalized = errorMessageCaseNormalization(errorMsg);
+ *
+ * if (normalized.includes('insufficient')) {
+ *   console.log('Balance error');
+ * }
+ * if (normalized.includes('transaction')) {
+ *   console.log('Tx error');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function errorMessageCaseNormalization(message: string): string;
+/**
+ * Case-insensitive substring search helper.
+ *
+ * Checks if a message contains a search string in a case-insensitive manner.
+ * Useful for error pattern matching and string validation.
+ *
+ * Consolidated from 3 duplicated patterns of case-insensitive contains checks:
+ * - `error.message.toLowerCase().includes(pattern.toLowerCase())`
+ * - `response.toLowerCase().includes('error')`
+ *
+ * @param message The message to search within
+ * @param searchString The substring to search for
+ * @returns True if message contains the search string (case-insensitive)
+ *
+ * @example Error condition checking
+ * ```typescript
+ * import { normalizeErrorMessage } from '@gala-chain/launchpad-sdk';
+ *
+ * try {
+ *   // ... operation
+ * } catch (error: any) {
+ *   // OLD: error.message.toLowerCase().includes('invalid')
+ *   // NEW:
+ *   if (normalizeErrorMessage(error.message, 'INVALID')) {
+ *     // Handle invalid input error
+ *   }
+ * }
+ * ```
+ *
+ * @example API response checking
+ * ```typescript
+ * import { normalizeErrorMessage } from '@gala-chain/launchpad-sdk';
+ *
+ * const response = 'ERROR: Invalid Token Name';
+ * if (normalizeErrorMessage(response, 'invalid token')) {
+ *   console.log('Token is invalid');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function normalizeErrorMessage(message: string, searchString: string): boolean;
+/**
+ * Check if two token pairs match in either order (bidirectional).
+ *
+ * Compares two pairs of tokens to see if they represent the same pair,
+ * accounting for different orderings (A,B matches B,A).
+ * Essential for pool pair matching in DEX operations.
+ *
+ * Consolidated from 4 duplicated patterns in bidirectional token matching:
+ * - `(token0 === tokenA && token1 === tokenB) || (token0 === tokenB && token1 === tokenA)`
+ * - Pool pair matching logic
+ *
+ * @param token0 First token in pair A
+ * @param token1 Second token in pair A
+ * @param tokenA First token in pair B
+ * @param tokenB Second token in pair B
+ * @returns True if both pairs represent the same token pair (in any order)
+ *
+ * @example Direct pool pair matching
+ * ```typescript
+ * import { bidirectionalTokenMatch } from '@gala-chain/launchpad-sdk';
+ *
+ * const poolToken0 = 'GALA';
+ * const poolToken1 = 'GUSDC';
+ *
+ * const searchToken0 = 'GUSDC';
+ * const searchToken1 = 'GALA';
+ *
+ * if (bidirectionalTokenMatch(poolToken0, poolToken1, searchToken0, searchToken1)) {
+ *   // Found matching pool (order doesn't matter)
+ * }
+ * ```
+ *
+ * @example Finding matching DEX pool
+ * ```typescript
+ * import { bidirectionalTokenMatch } from '@gala-chain/launchpad-sdk';
+ *
+ * const targetPool = { token0: 'GALA', token1: 'GUSDC' };
+ * const allPools = [...];
+ *
+ * const match = allPools.find(pool =>
+ *   bidirectionalTokenMatch(pool.token0, pool.token1, targetPool.token0, targetPool.token1)
+ * );
+ * ```
+ *
+ * @example Liquidity position matching
+ * ```typescript
+ * import { bidirectionalTokenMatch } from '@gala-chain/launchpad-sdk';
+ *
+ * const position = { token0: 'GUSDC', token1: 'GALA' };
+ * const newPoolTokens = { token0: 'GALA', token1: 'GUSDC' };
+ *
+ * if (bidirectionalTokenMatch(position.token0, position.token1, newPoolTokens.token0, newPoolTokens.token1)) {
+ *   console.log('Position is in the same pool');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function bidirectionalTokenMatch(token0: string, token1: string, tokenA: string, tokenB: string): boolean;
+/**
+ * Extract and normalize hex address from pipe-delimited format.
+ *
+ * Parses addresses in formats like 'eth|0x1234...' or plain '0x...' formats
+ * and returns the hex portion. Returns null if format is invalid or no hex found.
+ *
+ * Consolidated from 6 duplicated patterns in address extraction:
+ * - `const [chain, address] = addressLike.split('|')`
+ * - Manual hex extraction and validation
+ *
+ * @param addressLike Address string in 'chain|0xhex' or '0xhex' format
+ * @returns Hex address portion (without '0x' prefix), or null if invalid
+ *
+ * @example Basic hex extraction
+ * ```typescript
+ * import { hexStringExtractionAndNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * const ethAddress = 'eth|0x1234567890abcdef1234567890abcdef12345678';
+ * const hex = hexStringExtractionAndNormalization(ethAddress);
+ * console.log(hex); // '1234567890abcdef1234567890abcdef12345678'
+ *
+ * const plainHex = '0xabcdef0123456789abcdef0123456789abcdef01';
+ * const result = hexStringExtractionAndNormalization(plainHex);
+ * console.log(result); // 'abcdef0123456789abcdef0123456789abcdef01'
+ * ```
+ *
+ * @example GSwap user asset lookup
+ * ```typescript
+ * import { hexStringExtractionAndNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * const walletAddress = 'eth|0x1234567890abcdef...';
+ * const hexOnly = hexStringExtractionAndNormalization(walletAddress);
+ * if (hexOnly) {
+ *   const assets = await gswapService.getUserAssets(`eth|0x${hexOnly}`);
+ * }
+ * ```
+ *
+ * @example Error handling for invalid format
+ * ```typescript
+ * import { hexStringExtractionAndNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * const invalidAddress = 'not-an-address';
+ * const hex = hexStringExtractionAndNormalization(invalidAddress);
+ * if (hex === null) {
+ *   console.error('Invalid address format');
+ * }
+ * ```
+ *
+ * @example Client-side address handling
+ * ```typescript
+ * import { hexStringExtractionAndNormalization } from '@gala-chain/launchpad-sdk';
+ *
+ * const address = 'client|mongo-id-12345';
+ * const hex = hexStringExtractionAndNormalization(address);
+ * // For non-hex formats, returns null
+ * if (hex === null) {
+ *   // Not a hex address, handle differently
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function hexStringExtractionAndNormalization(addressLike: string): string | null;
+/**
+ * Check if a string is empty after trimming.
+ *
+ * Returns true if the value is falsy, not a string, or empty after trimming.
+ * Returns false if value is a non-empty string after trimming.
+ *
+ * Useful for quick validation checks in conditional logic.
+ *
+ * Consolidated from 5 duplicated patterns:
+ * - `value?.trim().length === 0`
+ * - `!value || !value.trim()`
+ *
+ * @param value Unknown input value to check
+ * @returns True if value is empty after trimming (or not a string), false if non-empty string
+ *
+ * @example String validation
+ * ```typescript
+ * import { trimmedLengthValidation } from '@gala-chain/launchpad-sdk';
+ *
+ * if (trimmedLengthValidation('')) {
+ *   console.log('Empty string');  // true
+ * }
+ *
+ * if (trimmedLengthValidation('  ')) {
+ *   console.log('Whitespace only');  // true
+ * }
+ *
+ * if (!trimmedLengthValidation('Hello')) {
+ *   console.log('Non-empty string');  // true
+ * }
+ * ```
+ *
+ * @example Chat message validation
+ * ```typescript
+ * import { trimmedLengthValidation } from '@gala-chain/launchpad-sdk';
+ *
+ * const userMessage = getUserInput();
+ * // OLD: if (userMessage?.trim().length === 0) { ... }
+ * // NEW:
+ * if (trimmedLengthValidation(userMessage)) {
+ *   console.log('Message is empty, skipping');
+ *   return;
+ * }
+ * // Message is valid, process it
+ * ```
+ *
+ * @example Conditional rendering
+ * ```typescript
+ * import { trimmedLengthValidation } from '@gala-chain/launchpad-sdk';
+ *
+ * const displayText = userComment;
+ * // Skip rendering if comment is empty
+ * if (!trimmedLengthValidation(displayText)) {
+ *   return <CommentDisplay text={displayText.trim()} />;
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function trimmedLengthValidation(value: unknown): boolean;
+//# sourceMappingURL=string-patterns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/string-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,GAAE,MAAU,GACpB,MAAM,GAAG,IAAI,CAkBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAKT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,wBAAgB,mCAAmC,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuBtF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK/D"}