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

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

@@ -1,404 +0,0 @@
-/**
- * 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: unknown) {
- *   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: unknown) {
- *   // 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

@@ -1 +0,0 @@
-{"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,UAAU,CAAC,EAAE,MAAM,EACnB,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"}

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

@@ -1,89 +0,0 @@
-/**
- * String Transformation Utilities
- *
- * Semantic wrappers and helpers for common string operations.
- * Consolidates 6 patterns found across 30+ occurrences in service files.
- *
- * @category Utilities
- * @since 5.16.0
- */
-/**
- * Truncate string with ellipsis if it exceeds max length
- *
- * Truncates the string and appends '...' if longer than max length.
- * Consolidates 7 occurrences across private key masking and message previews.
- *
- * @example
- * ```typescript
- * const masked = truncateWithEllipsis('0x1234567890abcdef', 10); // "0x12345678..."
- * const full = truncateWithEllipsis('short', 10); // "short"
- * ```
- */
-export declare function truncateWithEllipsis(str: string, maxLength: number): string;
-/**
- * Case-insensitive string containment check
- *
- * Returns true if haystack contains needle (case-insensitive).
- * Consolidates 2+ occurrences for case-insensitive search patterns.
- *
- * @example
- * ```typescript
- * const found = includesIgnoreCase('Hello World', 'hello'); // true
- * const notFound = includesIgnoreCase('Hello', 'xyz'); // false
- * ```
- */
-export declare function includesIgnoreCase(haystack: string, needle: string): boolean;
-/**
- * Generate random alphanumeric suffix
- *
- * Creates a random string of specified length using alphanumeric characters.
- * Used for generating unique keys and identifiers.
- * Consolidates 3 occurrences across unique-key-generator, multipart, and SignatureHelper.
- *
- * @example
- * ```typescript
- * const suffix = generateRandomSuffix(8); // "a1b2c3d4"
- * const longId = generateRandomSuffix(16); // "a1b2c3d4e5f6g7h8"
- * ```
- */
-export declare function generateRandomSuffix(length?: number): string;
-/**
- * Normalize seed to 64-character hex string
- *
- * Converts seed to hex format and pads/truncates to exactly 64 characters.
- * Consolidates 3 occurrences in test wallet seed generation.
- *
- * @example
- * ```typescript
- * const hex64 = normalizeTo64HexString('seed'); // "7365656457..." (64 chars)
- * ```
- */
-export declare function normalizeTo64HexString(seed: string): string;
-/**
- * Remove prefix from string if present
- *
- * Returns string without prefix if it starts with the prefix.
- * Otherwise returns the original string.
- * Consolidates 8+ occurrences for hex/address prefix removal.
- *
- * @example
- * ```typescript
- * const stripped = stripPrefixConditional('0xabc123', '0x'); // "abc123"
- * const noPrefix = stripPrefixConditional('abc123', '0x'); // "abc123"
- * ```
- */
-export declare function stripPrefixConditional(str: string, prefix: string): string;
-/**
- * Normalize string for case-insensitive comparison
- *
- * Converts string to uppercase for comparison purposes.
- * Consolidates 12+ occurrences for token symbol normalization.
- *
- * @example
- * ```typescript
- * const normalized = normalizeForComparison('gala'); // "GALA"
- * const isEqual = normalizeForComparison('ANIME') === normalizeForComparison('anime'); // true
- * ```
- */
-export declare function normalizeForComparison(str: string): string;
-//# sourceMappingURL=string-transforms.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"string-transforms.d.ts","sourceRoot":"","sources":["../../../src/utils/string-transforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,MAAU,GAAG,MAAM,CAK/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1D"}

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

@@ -1,108 +0,0 @@
-/**
- * String Manipulation Utilities
- *
- * Common string formatting operations consolidated from duplicated patterns
- * across error handling, field validation, and display formatting.
- *
- * @category Utilities
- * @since 6.13.1
- */
-/**
- * Capitalize a field name for display purposes.
- *
- * Converts camelCase field names to user-friendly display names by:
- * - Using provided displayName if available
- * - Otherwise capitalizing first letter of the field name
- *
- * Consolidated from 8 duplicated patterns in error message formatting.
- *
- * @param fieldName The camelCase field name to process
- * @param displayName Optional human-readable display name to use instead
- * @returns Capitalized display name
- *
- * @example Basic capitalization
- * ```typescript
- * import { capitalize } from '@gala-chain/launchpad-sdk';
- *
- * const display = capitalize('tokenName');
- * console.log(display); // 'TokenName'
- * ```
- *
- * @example With custom display name
- * ```typescript
- * import { capitalize } from '@gala-chain/launchpad-sdk';
- *
- * const display = capitalize('minFeePortion', 'Minimum Fee %');
- * console.log(display); // 'Minimum Fee %'
- * ```
- *
- * @example In error messages
- * ```typescript
- * import { capitalize } from '@gala-chain/launchpad-sdk';
- *
- * const fieldName = 'reverseBondingCurveMinFeeFactor';
- * const display = capitalize(fieldName, 'Minimum Fee Factor');
- * throw new Error(`${display} must be between 0.1 and 0.5`);
- * // → "Minimum Fee Factor must be between 0.1 and 0.5"
- * ```
- *
- * @example Fallback to automatic capitalization
- * ```typescript
- * import { capitalize } from '@gala-chain/launchpad-sdk';
- *
- * // When displayName not provided, capitalizes first letter
- * capitalize('amount');        // 'Amount'
- * capitalize('preBuyQuantity'); // 'PreBuyQuantity'
- * ```
- *
- * @since 6.13.1
- */
-export declare function capitalize(fieldName: string, displayName?: string): string;
-/**
- * Normalize token symbol to uppercase for case-insensitive comparison
- *
- * Converts token symbols to uppercase for consistent comparison operations.
- * Useful for filtering, searching, and comparing token symbols across
- * different sources that may use different casing conventions.
- *
- * Consolidated from 12 duplicated `.toUpperCase()` patterns in position filtering.
- *
- * @param symbol The token symbol to normalize (e.g., 'gala', 'GALA', 'Gala')
- * @returns Uppercase version of the symbol
- *
- * @example Basic normalization
- * ```typescript
- * import { normalizeTokenSymbol } from '@gala-chain/launchpad-sdk';
- *
- * normalizeTokenSymbol('gala');        // 'GALA'
- * normalizeTokenSymbol('GALA');        // 'GALA'
- * normalizeTokenSymbol('Gala');        // 'GALA'
- * ```
- *
- * @example In filtering operations
- * ```typescript
- * import { normalizeTokenSymbol } from '@gala-chain/launchpad-sdk';
- *
- * const searchSymbol = 'gusdc';
- * const normalized = normalizeTokenSymbol(searchSymbol);
- *
- * const pools = positions.filter(p =>
- *   normalizeTokenSymbol(p.token0) === normalized ||
- *   normalizeTokenSymbol(p.token1) === normalized
- * );
- * ```
- *
- * @example In token comparisons
- * ```typescript
- * import { normalizeTokenSymbol } from '@gala-chain/launchpad-sdk';
- *
- * const token0 = normalizeTokenSymbol(position.token0);
- * const token1 = normalizeTokenSymbol(position.token1);
- *
- * const isGALA = token0 === 'GALA' || token1 === 'GALA';
- * ```
- *
- * @since 3.50.0
- */
-export declare function normalizeTokenSymbol(symbol: string): string;
-//# sourceMappingURL=string-utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/string-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAK1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3D"}