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

package/dist/src/utils/token-parser.d.ts

@@ -1,235 +0,0 @@
-/**
- * Safe Token Parser - Comprehensive token format validation and parsing
- *
- * Handles STRICT parsing of token formats received from APIs:
- * - Pipe-delimited: "GALA|Unit|none|none"
- * - Dollar-delimited: "GALA$Unit$none$none"
- * - Dollar with $ in collection: "$MUSIC$Unit$none$none" (parses from END)
- *
- * CRITICAL SECURITY NOTE:
- * Plain strings like "GALA" are REJECTED by default - they are not valid token formats!
- * Token formats MUST be explicitly delimited with | or $.
- * This prevents dangerous assumptions about token structure.
- *
- * @packageDocumentation
- */
-import type { TokenClassKey } from '../types/common';
-/**
- * PERFORMANCE CHARACTERISTICS:
- *
- * Fast-path (O(n) where n = token length):
- * - Pipe-delimited tokens: Direct split() call, minimal string operations
- * - Dollar-delimited tokens: Reverse algorithm, ~2x string operations
- *
- * Slow-path (format detection):
- * - Plain strings without delimiters: Requires fallback logic
- * - Type validation: Object instanceof checks for already-parsed tokens
- *
- * Recommendation: Pre-detect format when parsing large token batches:
- * ```typescript
- * import { isPipeDelimited, isDollarDelimited } from './token-parser';
- *
- * if (isPipeDelimited(token)) {
- *   return parsePipeDelimitedToken(token);  // Fastest path
- * } else if (isDollarDelimited(token)) {
- *   return parseDollarDelimitedTokenSafe(token);  // Fast path
- * }
- * ```
- */
-/**
- * Parse token from ANY format (pipe/dollar delimited) into TokenClassKey
- *
- * Accepts:
- * - Pipe format: "GALA|Unit|none|none"
- * - Dollar format: "GALA$Unit$none$none"
- * - Dollar with $ in collection: "$MUSIC$Unit$none$none"
- * - TokenClassKey objects: { collection, category, type, additionalKey }
- *
- * REJECTS:
- * - Plain strings like "GALA" (DANGEROUS - no delimiters!)
- * - Null/undefined values
- * - Invalid formats
- *
- * ⚠️ SECURITY ENFORCEMENT (v3.33.0+):
- * Plain token strings are NO LONGER accepted. All tokens must use explicit delimiters.
- * This is a breaking change to enforce secure token format validation.
- *
- * @param token Token string to parse
- * @returns TokenClassKey with { collection, category, type, additionalKey }
- * @throws ValidationError if format is invalid or if plain string is provided
- *
- * @example
- * ```typescript
- * // Pipe-delimited (RECOMMENDED)
- * parseToken("GALA|Unit|none|none")
- * // → { collection: "GALA", category: "Unit", type: "none", additionalKey: "none" }
- *
- * // Dollar-delimited
- * parseToken("GALA$Unit$none$none")
- * // → { collection: "GALA", category: "Unit", type: "none", additionalKey: "none" }
- *
- * // Dollar with $ in collection (EDGE CASE)
- * parseToken("$MUSIC$Unit$none$none")
- * // → { collection: "$MUSIC", category: "Unit", type: "none", additionalKey: "none" }
- *
- * // TokenClassKey object
- * parseToken({ collection: "GALA", category: "Unit", type: "none", additionalKey: "none" })
- * // → { collection: "GALA", category: "Unit", type: "none", additionalKey: "none" }
- *
- * // Plain string - PERMANENTLY REJECTED
- * parseToken("GALA")  // Throws ValidationError
- * ```
- *
- * @since 3.32.0
- * @updated 3.33.0 - Removed allowPlainStrings parameter, enforce strict delimiter-only parsing
- */
-export declare function parseToken(token: string | TokenClassKey | undefined | null): TokenClassKey;
-/**
- * Parse pipe-delimited token: "GALA|Unit|none|none"
- *
- * @internal Used by parseToken()
- * @throws ValidationError if format is invalid
- */
-export declare function parsePipeDelimitedToken(token: string): TokenClassKey;
-/**
- * REVERSE-PARSING ALGORITHM FOR DOLLAR-DELIMITED TOKENS
- *
- * Problem: Tokens like "$MUSIC$Unit$none$none" contain $ in the collection name
- * Standard left-to-right parsing fails because it can't distinguish where collection ends
- *
- * Solution: Parse from RIGHT-TO-LEFT
- *
- * ```
- * Input token: "$MUSIC$Unit$none$none"
- *              [   1  ][2  ][3  ][4  ]   ← parts array (5 elements)
- *
- * Step 1: Split by '$'
- *   parts = ['', 'MUSIC', 'Unit', 'none', 'none']
- *
- * Step 2: Take last 3 parts (from right)
- *   category = parts[2] = 'Unit'
- *   type     = parts[3] = 'none'
- *   additionalKey = parts[4] = 'none'
- *
- * Step 3: Everything BEFORE those 3 parts = collection (rejoin with '$')
- *   collectionParts = parts[0:2] = ['', 'MUSIC']
- *   collection = '$MUSIC' (rejoin with '$')
- *
- * Result: { collection: "$MUSIC", category: "Unit", type: "none", additionalKey: "none" } ✓
- * ```
- *
- * Why this works:
- * - Handles ANY number of $ characters in collection
- * - Guarantees exactly 4 components (collection, category, type, additionalKey)
- * - Clear error messages when format is invalid
- *
- * Edge cases handled:
- * - "$MUSIC$Unit$none$none" → collection: "$MUSIC" ✓
- * - "COLLECTION$WITH$DOLLARS$Unit$symbol$additionalKey" → works ✓
- * - "NotEnoughParts$Unit$none" → throws ValidationError ✓
- *
- * Performance: O(n) where n = token length (single split + slice + rejoin operations)
- */
-/**
- * Parse dollar-delimited token: "GALA$Unit$none$none"
- *
- * CRITICAL: Handles edge case where $ is part of collection name
- * Example: "$MUSIC$Unit$none$none" -> { collection: "$MUSIC", ... }
- *
- * Solution: Parse from END backwards
- * - Last 3 parts (from right): category, type, additionalKey
- * - Everything else: collection
- *
- * @internal Used by parseToken()
- * @throws ValidationError if format is invalid
- */
-export declare function parseDollarDelimitedTokenSafe(token: string): TokenClassKey;
-/**
- * Check if token string is in pipe-delimited format
- *
- * @example
- * ```typescript
- * isPipeDelimited("GALA|Unit|none|none") // → true
- * isPipeDelimited("GALA") // → false
- * ```
- */
-export declare function isPipeDelimited(token: string): boolean;
-/**
- * Check if token string is in dollar-delimited format
- *
- * @example
- * ```typescript
- * isDollarDelimited("GALA$Unit$none$none") // → true
- * isDollarDelimited("$MUSIC$Unit$none$none") // → true
- * isDollarDelimited("GALA") // → false
- * ```
- */
-export declare function isDollarDelimited(token: string): boolean;
-/**
- * Check if token is in ANY valid delimited format (pipe or dollar)
- *
- * @example
- * ```typescript
- * isDelimited("GALA|Unit|none|none") // → true
- * isDelimited("GALA$Unit$none$none") // → true
- * isDelimited("GALA") // → false
- * ```
- */
-export declare function isDelimited(token: string): boolean;
-/**
- * Check if a value is a valid token format (string OR TokenClassKey object)
- *
- * @param token Token to validate
- * @returns true if token is valid format (pipe/dollar delimited OR TokenClassKey object)
- *
- * @example
- * ```typescript
- * isValidTokenFormat("GALA|Unit|none|none")  // → true
- * isValidTokenFormat("GALA$Unit$none$none")  // → true
- * isValidTokenFormat({ collection: "GALA", ... })  // → true
- * isValidTokenFormat("GALA")  // → false (plain string, not delimited)
- * ```
- */
-export declare function isValidTokenFormat(token: unknown): boolean;
-/**
- * Check if token is a plain symbol string (NOT a delimited format)
- *
- * Plain token symbols are simple strings like "GALA", "USDC", etc.
- * These are REJECTED by default by parseToken() for security reasons.
- * Use parseToken(symbol, true) to parse plain symbols.
- *
- * @param token Token to check
- * @returns true if token is plain symbol (no delimiters)
- *
- * @example
- * ```typescript
- * isPlainTokenSymbol("GALA")  // → true
- * isPlainTokenSymbol("GALA|Unit|none|none")  // → false
- * isPlainTokenSymbol("GALA$Unit$none$none")  // → false
- * ```
- *
- * @security WARNING: Plain tokens are inherently ambiguous!
- * Always use delimited formats when possible.
- */
-export declare function isPlainTokenSymbol(token: unknown): boolean;
-/**
- * Type guard: Check if value is a TokenClassKey object
- *
- * @param token Value to check
- * @returns true if token is a valid TokenClassKey object with all required properties
- *
- * @example
- * ```typescript
- * const value: string | TokenClassKey = getToken();
- *
- * if (isTokenClassKey(value)) {
- *   // TypeScript now knows value is TokenClassKey
- *   console.log(value.collection, value.category, value.type, value.additionalKey);
- * } else {
- *   // value is string
- *   console.log(parseToken(value));
- * }
- * ```
- */
-export declare function isTokenClassKey(token: unknown): token is TokenClassKey;
-//# sourceMappingURL=token-parser.d.ts.map

package/dist/src/utils/token-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/token-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,GAAG,IAAI,GAC/C,aAAa,CAyCf;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAGpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAG1E;AAGD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAe1D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAqBtE"}

package/dist/src/utils/token-stringification.d.ts

@@ -1,168 +0,0 @@
-/**
- * Token Stringification Utilities
- *
- * @category Utilities
- * @since 6.6.0
- */
-import type { TokenClassKey, TokenInstanceKey } from '../types/common';
-/**
- * Convert a TokenClassKey to pipe-delimited string format
- *
- * This is the canonical function for converting TokenClassKey objects to strings.
- * All services should use this instead of inline template literals.
- *
- * @param token TokenClassKey object with collection, category, type, additionalKey
- * @returns Pipe-delimited string in format "collection|category|type|additionalKey"
- *
- * @example
- * ```typescript
- * import { stringifyTokenClassKey } from '../utils/token-stringification';
- *
- * const tokenId = stringifyTokenClassKey({
- *   collection: 'GALA',
- *   category: 'Unit',
- *   type: 'none',
- *   additionalKey: 'none'
- * });
- * // Returns: "GALA|Unit|none|none"
- *
- * const launchpadToken = stringifyTokenClassKey({
- *   collection: 'Token',
- *   category: 'Unit',
- *   type: 'BENE',
- *   additionalKey: 'client:5c806869e7fd0e2384461ce9'
- * });
- * // Returns: "Token|Unit|BENE|client:5c806869e7fd0e2384461ce9"
- * ```
- *
- * @since 6.6.0
- */
-export declare function stringifyTokenClassKey(token: TokenClassKey): string;
-/**
- * Convert a TokenInstanceKey to pipe-delimited string format (with instance)
- *
- * Similar to stringifyTokenClassKey but includes the instance field for
- * operations that require full token instance identification.
- *
- * @param token TokenInstanceKey object with collection, category, type, additionalKey, instance
- * @returns Pipe-delimited string in format "collection|category|type|additionalKey|instance"
- *
- * @example
- * ```typescript
- * import { stringifyTokenInstanceKey } from '../utils/token-stringification';
- *
- * const tokenId = stringifyTokenInstanceKey({
- *   collection: 'GALA',
- *   category: 'Unit',
- *   type: 'none',
- *   additionalKey: 'none',
- *   instance: '0'
- * });
- * // Returns: "GALA|Unit|none|none|0"
- * ```
- *
- * @since 6.6.0
- */
-export declare function stringifyTokenInstanceKey(token: TokenInstanceKey): string;
-/**
- * Convert either TokenClassKey or TokenInstanceKey to string
- *
- * Automatically detects the token type and uses the appropriate stringification.
- * If instance is present and not undefined, includes it in the output.
- *
- * @param token Token object (TokenClassKey or TokenInstanceKey)
- * @returns Pipe-delimited string
- *
- * @example
- * ```typescript
- * import { stringifyToken } from '../utils/token-stringification';
- *
- * // TokenClassKey (4-part output)
- * stringifyToken({ collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' });
- * // Returns: "GALA|Unit|none|none"
- *
- * // TokenInstanceKey (5-part output)
- * stringifyToken({ collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none', instance: '0' });
- * // Returns: "GALA|Unit|none|none|0"
- * ```
- *
- * @since 6.6.0
- */
-export declare function stringifyToken(token: TokenClassKey | TokenInstanceKey): string;
-/**
- * Convert TokenClassKey to dollar-delimited string format
- *
- * This is used internally by GalaChain for state ledger key generation.
- * The format uses dollar signs instead of pipes as delimiters.
- *
- * @param token TokenClassKey object
- * @returns Dollar-delimited string in format "collection$category$type$additionalKey"
- *
- * @example
- * ```typescript
- * import { stringifyTokenClassKeyDollar } from '../utils/token-stringification';
- *
- * const tokenId = stringifyTokenClassKeyDollar({
- *   collection: 'GALA',
- *   category: 'Unit',
- *   type: 'none',
- *   additionalKey: 'none'
- * });
- * // Returns: "GALA$Unit$none$none"
- * ```
- *
- * @since 6.7.0
- */
-export declare function stringifyTokenClassKeyDollar(token: TokenClassKey): string;
-/**
- * Convert TokenInstanceKey to dollar-delimited string format (with instance)
- *
- * Similar to stringifyTokenClassKeyDollar but includes the instance field.
- * Used for operations requiring full token instance identification with GalaChain format.
- *
- * @param token TokenInstanceKey object
- * @returns Dollar-delimited string in format "collection$category$type$additionalKey$instance"
- *
- * @example
- * ```typescript
- * import { stringifyTokenInstanceKeyDollar } from '../utils/token-stringification';
- *
- * const tokenId = stringifyTokenInstanceKeyDollar({
- *   collection: 'GALA',
- *   category: 'Unit',
- *   type: 'none',
- *   additionalKey: 'none',
- *   instance: '0'
- * });
- * // Returns: "GALA$Unit$none$none$0"
- * ```
- *
- * @since 6.7.0
- */
-export declare function stringifyTokenInstanceKeyDollar(token: TokenInstanceKey): string;
-/**
- * Convert TokenClassKey to dollar-delimited string format with prefix
- *
- * This is used for GalaChain ledger key generation where keys are prefixed with $.
- * Used in services like GSwapService and GSwapLiquidityMutationService.
- *
- * @param token TokenClassKey object
- * @returns Dollar-delimited string with $ prefix in format "$collection$category$type$additionalKey"
- *
- * @example
- * ```typescript
- * import { stringifyTokenClassKeyDollarPrefixed } from '../utils/token-stringification';
- *
- * const tokenKey = stringifyTokenClassKeyDollarPrefixed({
- *   collection: 'GALA',
- *   category: 'Unit',
- *   type: 'none',
- *   additionalKey: 'none'
- * });
- * // Returns: "$GALA$Unit$none$none"
- * ```
- *
- * @since 6.7.0
- */
-export declare function stringifyTokenClassKeyDollarPrefixed(token: TokenClassKey): string;
-//# sourceMappingURL=token-stringification.d.ts.map

package/dist/src/utils/token-stringification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token-stringification.d.ts","sourceRoot":"","sources":["../../../src/utils/token-stringification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,GAAG,MAAM,CAM9E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAEzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAE/E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAEjF"}

package/dist/src/utils/tokenNameNormalizer.d.ts

@@ -1,96 +0,0 @@
-/**
- * Token Name Normalizer
- *
- * Shared utility for normalizing token identifiers for consistent API usage and cache keys.
- *
- * ## Normalization Patterns
- * - **normalizeTokenName**: Lowercase normalization for launchpad token names (backend storage format)
- * - **normalizeTokenKey**: Uppercase normalization for cache keys (symbols, tokenIds)
- *
- * @category Utilities
- * @since 6.3.0
- */
-/**
- * Normalizes a launchpad token name for consistent API usage.
- *
- * All token names are stored lowercase in the backend. This utility ensures
- * consistent normalization across all SDK services.
- *
- * Current normalizations:
- * - `.trim()` - Remove leading/trailing whitespace
- * - `.toLowerCase()` - Convert to lowercase
- *
- * @param tokenName The token name to normalize
- * @returns Normalized token name (trimmed and lowercased)
- *
- * @example
- * ```typescript
- * import { normalizeTokenName } from '../utils/tokenNameNormalizer';
- *
- * const normalized = normalizeTokenName('  MyToken  ');
- * console.log(normalized); // 'mytoken'
- * ```
- */
-export declare function normalizeTokenName(tokenName: string): string;
-/**
- * Normalizes a token identifier for consistent cache keys.
- *
- * Used by cache services (BridgeableTokenCache, WrappableTokenCache) for
- * case-insensitive lookups of token symbols and tokenIds.
- *
- * Current normalizations:
- * - `.trim()` - Remove leading/trailing whitespace
- * - `.toUpperCase()` - Convert to uppercase
- *
- * **Note:** This uppercases the ENTIRE string including pipe-delimited tokenIds.
- * This is intentional for cache lookup consistency - both the cache key and
- * the lookup key are normalized identically. The original casing is preserved
- * in the cached values themselves, not the keys.
- *
- * @param key The token identifier (symbol or tokenId) to normalize
- * @returns Normalized key (trimmed and uppercased)
- *
- * @example
- * ```typescript
- * import { normalizeTokenKey } from '../utils/tokenNameNormalizer';
- *
- * const normalized = normalizeTokenKey('  gala  ');
- * console.log(normalized); // 'GALA'
- *
- * // Full tokenId also uppercased (intentional for cache key consistency)
- * const tokenId = normalizeTokenKey('GUSDC|Unit|none|eth:0x...');
- * console.log(tokenId); // 'GUSDC|UNIT|NONE|ETH:0X...'
- * ```
- *
- * @since 6.4.0
- */
-export declare function normalizeTokenKey(key: string): string;
-/**
- * Normalizes a token symbol for API submission
- *
- * Used during token creation to prepare user-provided token symbols
- * for API validation. Removes whitespace and converts to uppercase.
- *
- * **Distinction from normalizeTokenKey():**
- * - normalizeTokenKey: Cache keys (includes additional transformations)
- * - normalizeTokenSymbol: User input preparation (pure trim + uppercase)
- *
- * Current normalizations:
- * - `.trim()` - Remove leading/trailing whitespace
- * - `.toUpperCase()` - Convert to uppercase
- *
- * @param symbol The token symbol to normalize
- * @returns Normalized symbol (trimmed and uppercased)
- *
- * @example
- * ```typescript
- * import { normalizeTokenSymbol } from '../utils/tokenNameNormalizer';
- *
- * const symbol = normalizeTokenSymbol('  gala  ');
- * console.log(symbol); // 'GALA'
- * ```
- *
- * @since 6.15.1
- */
-export declare function normalizeTokenSymbol(symbol: string): string;
-//# sourceMappingURL=tokenNameNormalizer.d.ts.map

package/dist/src/utils/tokenNameNormalizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenNameNormalizer.d.ts","sourceRoot":"","sources":["../../../src/utils/tokenNameNormalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/src/utils/tokenNormalizer.d.ts

@@ -1,167 +0,0 @@
-/**
- * Token Normalization Utilities
- *
- * This module provides utilities for normalizing different token identifier formats
- * into a consistent TokenInstanceKey format that can be used with GalaChain APIs.
- */
-import type { TokenClassKey, TokenId, TokenInstanceKey } from '../types/common';
-import { isTokenClassKey as isTokenClassKeyStrict } from './token-parser';
-/**
- * Normalizes any token identifier format to TokenInstanceKey
- *
- * Accepts:
- * - String format: "collection|category|type|additionalKey" or "collection|category|type|additionalKey|instance"
- * - TokenClassKey object: { collection, category, type, additionalKey }
- * - TokenInstanceKey object: { collection, category, type, additionalKey, instance }
- *
- * @param tokenId Token identifier in any supported format
- * @returns TokenInstanceKey with instance defaulted to "0" if not provided
- * @throws ValidationError if the format is invalid
- *
- * @example
- * ```typescript
- * // String format (no instance)
- * const result1 = normalizeToTokenInstanceKey("GALA|Unit|none|none");
- * // → { collection: "GALA", category: "Unit", type: "none", additionalKey: "none", instance: "0" }
- *
- * // String format (with instance)
- * const result2 = normalizeToTokenInstanceKey("Token|Unit|UNI|eth:address|1");
- * // → { collection: "Token", category: "Unit", type: "UNI", additionalKey: "eth:address", instance: "1" }
- *
- * // TokenClassKey object
- * const tokenClass = { collection: "Token", category: "Unit", type: "UNI", additionalKey: "eth:address" };
- * const result3 = normalizeToTokenInstanceKey(tokenClass);
- * // → { collection: "Token", category: "Unit", type: "UNI", additionalKey: "eth:address", instance: "0" }
- *
- * // TokenInstanceKey object (already normalized)
- * const tokenInstance = { collection: "GALA", category: "Unit", type: "none", additionalKey: "none", instance: "0" };
- * const result4 = normalizeToTokenInstanceKey(tokenInstance);
- * // → Same object returned
- * ```
- */
-export declare function normalizeToTokenInstanceKey(tokenId: TokenId): TokenInstanceKey;
-/**
- * Type guard to check if a TokenId is a TokenInstanceKey object
- *
- * @param tokenId Token identifier to check
- * @returns True if tokenId is a TokenInstanceKey object
- */
-export declare function isTokenInstanceKey(tokenId: TokenId): tokenId is TokenInstanceKey;
-/**
- * Strict type guard that validates all TokenClassKey fields are non-empty strings.
- *
- * Re-export of `isTokenClassKey` from `./token-parser` for convenience.
- * This is the recommended function for validating TokenClassKey objects.
- *
- * @see isTokenClassKey from './token-parser' for the canonical implementation
- * @since 6.6.1
- */
-export { isTokenClassKeyStrict };
-/**
- * Type guard to check if a TokenId is a string
- *
- * @param tokenId Token identifier to check
- * @returns True if tokenId is a string
- */
-export declare function isTokenIdString(tokenId: TokenId): tokenId is string;
-/**
- * Validates that a TokenId has all required fields
- *
- * @param tokenId Token identifier to validate
- * @throws ValidationError if validation fails
- */
-export declare function validateTokenId(tokenId: TokenId): void;
-/**
- * Parses a vault address into a TokenClassKey
- *
- * Vault address format: "service|Token$Unit$SYMBOL$additionalKey$launchpad"
- * This consolidates 5+ identical vault address parsing patterns scattered across services.
- *
- * Handles additionalKey that may contain $ characters by excluding the 'launchpad' suffix
- * and joining all remaining parts.
- *
- * @param vaultAddress Vault address string to parse
- * @returns TokenClassKey object
- * @throws ValidationError if the vault address format is invalid
- *
- * @example
- * ```typescript
- * const tokenClass = parseVaultAddressToTokenClassKey(
- *   "service|Token$Unit$DRAGNRKTI$eth:0x...$launchpad"
- * );
- * // → { collection: "Token", category: "Unit", type: "DRAGNRKTI", additionalKey: "eth:0x..." }
- * ```
- *
- * @since 3.32.0
- */
-export declare function parseVaultAddressToTokenClassKey(vaultAddress: string): TokenClassKey;
-/**
- * Parses a vault address into a TokenInstanceKey
- *
- * Vault address format: "service|Token$Unit$SYMBOL$eth:address$launchpad"
- * Instance is defaulted to "0" if not provided in the vault address.
- *
- * @param vaultAddress Vault address string to parse
- * @returns TokenInstanceKey object with instance defaulted to "0"
- * @throws ValidationError if the vault address format is invalid
- *
- * @example
- * ```typescript
- * const tokenInstance = parseVaultAddressToTokenInstance(
- *   "service|Token$Unit$DRAGNRKTI$eth:0x...$launchpad"
- * );
- * // → { collection: "Token", category: "Unit", type: "DRAGNRKTI", additionalKey: "eth:0x...", instance: "0" }
- * ```
- *
- * @since 3.32.0
- */
-export declare function parseVaultAddressToTokenInstance(vaultAddress: string): TokenInstanceKey;
-/**
- * Extracts the token symbol/type from a vault address
- *
- * Vault address format: "service|Token$Unit$SYMBOL$eth:address$launchpad"
- * The symbol is the 3rd component (index 2) after splitting the token part by $.
- *
- * @param vaultAddress Vault address string to parse
- * @returns Token symbol/type (e.g., "DRAGNRKTI", "GALA", "GUSDC")
- * @throws ValidationError if the vault address format is invalid
- *
- * @example
- * ```typescript
- * const symbol = extractTokenSymbolFromVault(
- *   "service|Token$Unit$DRAGNRKTI$eth:0x...$launchpad"
- * );
- * // → "DRAGNRKTI"
- * ```
- *
- * @since 3.32.0
- */
-export declare function extractTokenSymbolFromVault(vaultAddress: string): string;
-/**
- * Validates and normalizes a TokenId to pipe-delimited string format (4 parts, no instance)
- *
- * This is the standard format used in API requests and cache keys.
- * For TokenClassKey format (without instance), use this function.
- *
- * @param tokenId Token identifier in any supported format
- * @returns Normalized string in format "collection|category|type|additionalKey"
- * @throws ValidationError if tokenId format is invalid
- *
- * @example
- * ```typescript
- * // String input - validated and returned
- * normalizeTokenIdToString('GALA|Unit|none|none') // → 'GALA|Unit|none|none'
- *
- * // TokenClassKey object - converted to string
- * normalizeTokenIdToString({
- *   collection: 'Token', category: 'Unit', type: 'GWETH', additionalKey: 'eth:0x...'
- * }) // → 'Token|Unit|GWETH|eth:0x...'
- *
- * // Invalid format throws
- * normalizeTokenIdToString('GALA') // ❌ ValidationError
- * ```
- *
- * @since 5.0.2
- */
-export declare function normalizeTokenIdToString(tokenId: TokenId): string;
-//# sourceMappingURL=tokenNormalizer.d.ts.map

package/dist/src/utils/tokenNormalizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenNormalizer.d.ts","sourceRoot":"","sources":["../../../src/utils/tokenNormalizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAIhF,OAAO,EAEL,eAAe,IAAI,qBAAqB,EAEzC,MAAM,gBAAgB,CAAC;AAGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,CAsE9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAOhF;AAED;;;;;;;;GAQG;AACH,OAAO,EAAE,qBAAqB,EAAE,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,MAAM,CAEnE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CActD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAGpF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAMvF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAMjE"}