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

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

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

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

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

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

package/dist/src/utils/swap-delta-calculator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swap-delta-calculator.d.ts","sourceRoot":"","sources":["../../../src/utils/swap-delta-calculator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIjD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAGtE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IAEtB,0DAA0D;IAC1D,oBAAoB,EAAE,OAAO,CAAC;IAE9B,oDAAoD;IACpD,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC;IAErC,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;CACvB;AAYD;;;;GAIG;AACH,UAAU,cAAc;IACtB,gDAAgD;IAChD,KAAK,EAAE,iBAAiB,CAAC;IAEzB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;IAEvB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAElB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,OAAO,CAAC,qBAAqB,CAAM,GAC1C,eAAe;IA4GlB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,mBAAmB,CACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,iBAAiB;IAkEpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,cAAc;IAgKjB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,iBAAiB,CACtB,YAAY,EAAE,IAAI,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,qBAAqB,GAC7B,IAAI;IA4BP;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,qBAAqB,CAC1B,YAAY,EAAE,iBAAiB,EAC/B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,EAAE,aAAa,GACvB;QACD,OAAO,EAAE,SAAS,CAAC;QACnB,OAAO,EAAE,SAAS,CAAC;QACnB,UAAU,EAAE,SAAS,CAAC;QACtB,UAAU,EAAE,SAAS,CAAC;KACvB;IAyDD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA0CtC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAqE/B;AAED;;;GAGG;AACH,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"swap-delta-calculator.d.ts","sourceRoot":"","sources":["../../../src/utils/swap-delta-calculator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAejD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAGtE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IAEtB,0DAA0D;IAC1D,oBAAoB,EAAE,OAAO,CAAC;IAE9B,oDAAoD;IACpD,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC;IAErC,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;CACvB;AAYD;;;;GAIG;AACH,UAAU,cAAc;IACtB,gDAAgD;IAChD,KAAK,EAAE,iBAAiB,CAAC;IAEzB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;IAEvB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAElB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,OAAO,CAAC,qBAAqB,CAAM,GAC1C,eAAe;IA4GlB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,mBAAmB,CACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,iBAAiB;IAkEpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,cAAc;IAgKjB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,iBAAiB,CACtB,YAAY,EAAE,IAAI,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,qBAAqB,GAC7B,IAAI;IA4BP;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,qBAAqB,CAC1B,YAAY,EAAE,iBAAiB,EAC/B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,EAAE,aAAa,GACvB;QACD,OAAO,EAAE,SAAS,CAAC;QACnB,OAAO,EAAE,SAAS,CAAC;QACnB,UAAU,EAAE,SAAS,CAAC;QACtB,UAAU,EAAE,SAAS,CAAC;KACvB;IAyDD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA0CtC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAqE/B;AAED;;;GAGG;AACH,eAAe,mBAAmB,CAAC"}

package/dist/src/utils/tick-crossing-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tick-crossing-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/tick-crossing-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,QAAQ,EAGT,MAAM,iBAAiB,CAAC;AACzB,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGvE;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,SAAqB;IAE7C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,SAAqB;IAE7C;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,qBAAqB,MAAM;IAE3C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,MAAM;IAE9C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,uBAAuB,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,OAAO,CAAC;IAwCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,SAAS,EAC3B,gBAAgB,EAAE,SAAS,EAC3B,UAAU,EAAE,OAAO,GAClB,SAAS;IAyBZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,cAAc,CACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,QAAQ,GACpB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAY3B;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG;QACtC,cAAc,EAAE,SAAS,CAAC;QAC1B,cAAc,EAAE,SAAS,CAAC;KAC3B;IAqBD;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,EAAE;IA2B5F;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,uBAAuB,CAC5B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,IAAI,GAAG,MAAM,EACxB,YAAY,EAAE,SAAS,EACvB,eAAe,EAAE,SAAS,EAC1B,cAAc,EAAE,SAAS,GACxB,iBAAiB;IAUpB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAgB9D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,OAAe,GAC3B,QAAQ,GAAG,SAAS;IAavB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAU3D"}
+{"version":3,"file":"tick-crossing-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/tick-crossing-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,QAAQ,EAGT,MAAM,iBAAiB,CAAC;AACzB,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAKvE;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,SAAqB;IAE7C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,SAAqB;IAE7C;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,qBAAqB,MAAM;IAE3C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,MAAM;IAE9C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,uBAAuB,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,OAAO,CAAC;IA6CpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,SAAS,EAC3B,gBAAgB,EAAE,SAAS,EAC3B,UAAU,EAAE,OAAO,GAClB,SAAS;IAyBZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,cAAc,CACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,QAAQ,GACpB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAY3B;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG;QACtC,cAAc,EAAE,SAAS,CAAC;QAC1B,cAAc,EAAE,SAAS,CAAC;KAC3B;IA2BD;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,EAAE;IA+B5F;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,uBAAuB,CAC5B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,IAAI,GAAG,MAAM,EACxB,YAAY,EAAE,SAAS,EACvB,eAAe,EAAE,SAAS,EAC1B,cAAc,EAAE,SAAS,GACxB,iBAAiB;IAUpB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAgB9D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,OAAe,GAC3B,QAAQ,GAAG,SAAS;IAavB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAa3D"}

package/dist/src/utils/token-format-converter.d.ts

@@ -21,6 +21,8 @@
  *
  * Launchpad SDK uses: { collection, category, type, additionalKey }
  * GSwap SDK uses: "GALA|Unit|none|none" (pipe-delimited string)
+ *
+ * @packageDocumentation
  */
 import type { TokenClass } from '../types/gswap.dto';
 import type { TokenClassKey } from '../types/common';
@@ -56,12 +58,6 @@ export declare class TokenFormatConverter {
      * Output: TokenClassKey with collection, category, type, additionalKey
      */
     toTokenClass(token: string | TokenClass | any): TokenClass;
-    /**
-     * Check if token is in pipe-delimited format
-     * Input: "GALA|Unit|none|none" → true
-     * Input: "GALA" → false
-     */
-    isGSwapFormat(token: string): boolean;
     /**
      * INTERNAL USE ONLY: Normalize API response data that may contain bare symbols.
      *
@@ -134,12 +130,24 @@ export declare function dollarFormatToPipeFormat(dollarToken: string): string;
  */
 export declare function convertSortOrderToApi(sortOrder?: 'ASC' | 'DESC'): 'asc' | 'desc' | undefined;
 /**
- * Parse dollar-delimited token string into TokenClassKey components
+ * Parse dollar-delimited token string into TokenClassKey components (LEFT-TO-RIGHT)
  *
  * Dollar-delimited format: "Token$Unit$SYMBOL$additionalKey"
  * Handles additionalKey that may contain $ characters by treating everything after the third $
  * as part of additionalKey and rejoining with $.
- * This consolidates 5+ identical dollar-delimited parsing patterns scattered across services.
+ *
+ * **WARNING:** This function parses LEFT-TO-RIGHT which does NOT handle the edge case
+ * where the collection name contains $ (e.g., "$MUSIC$Unit$none$none").
+ * For tokens that may have $ in the collection, use `parseDollarDelimitedTokenSafe`
+ * from `./token-parser.ts` which parses RIGHT-TO-LEFT.
+ *
+ * ## When to use which function:
+ *
+ * - **parseDollarDelimitedToken** (this function): When you're certain the collection
+ *   does NOT contain $ characters. Slightly simpler, parses left-to-right.
+ *
+ * - **parseDollarDelimitedTokenSafe** (from token-parser.ts): When you need to handle
+ *   the "$MUSIC" edge case where collection name starts with $. Parses right-to-left.
  *
  * @param dollarToken Dollar-delimited token string to parse
  * @returns TokenClassKey object with collection, category, type, additionalKey
@@ -153,8 +161,14 @@ export declare function convertSortOrderToApi(sortOrder?: 'ASC' | 'DESC'): 'asc'
  * // Handles additionalKey with $ characters
  * const complex = parseDollarDelimitedToken('SYMBOL$Unit$none$eth:0x$1234$5678');
  * // → { collection: "SYMBOL", category: "Unit", type: "none", additionalKey: "eth:0x$1234$5678" }
+ *
+ * // WARNING: Does NOT handle $ in collection correctly!
+ * // parseDollarDelimitedToken('$MUSIC$Unit$none$none')
+ * // → { collection: "", category: "MUSIC", type: "Unit", additionalKey: "none$none" } // WRONG!
+ * // Use parseDollarDelimitedTokenSafe for this case.
  * ```
  *
+ * @see parseDollarDelimitedTokenSafe - Handles $ in collection name (RIGHT-TO-LEFT parsing)
  * @since 3.32.0
  */
 export declare function parseDollarDelimitedToken(dollarToken: string): TokenClassKey;

package/dist/src/utils/token-format-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-format-converter.d.ts","sourceRoot":"","sources":["../../../src/utils/token-format-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,qBAAa,oBAAoB;IAC/B;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAEf,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,GAAG,GAC/B,MAAM;IAqCT;;;;;;;;;;;;OAYG;IAEH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,GAAG,GAAG,UAAU;IAiC1D;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;;;;;;OAWG;IACH,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAenD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM;CAY9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,CAM5F;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAyC5E"}
+{"version":3,"file":"token-format-converter.d.ts","sourceRoot":"","sources":["../../../src/utils/token-format-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAOrD,qBAAa,oBAAoB;IAC/B;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAEf,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,GAAG,GAC/B,MAAM;IAwCT;;;;;;;;;;;;OAYG;IAEH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,GAAG,GAAG,UAAU;IA4B1D;;;;;;;;;;;OAWG;IACH,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAenD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM;CAY9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,CAM5F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAG5E"}

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

@@ -133,8 +133,8 @@ export declare function parsePipeDelimitedToken(token: string): TokenClassKey;
 /**
  * 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", ... }
+ * 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

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

@@ -1 +1 @@
-{"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;AAGrD;;;;;;;;;;;;;;;;;;;;;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,CA6CpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CA8C1E;AA4DD;;;;;;;;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,CAiBtE"}
+{"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,CAiBtE"}

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

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

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

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

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

@@ -5,6 +5,7 @@
  * into a consistent TokenInstanceKey format that can be used with GalaChain APIs.
  */
 import { TokenId, TokenClassKey, TokenInstanceKey } from '../types/common';
+import { isTokenClassKey as isTokenClassKeyStrict } from './token-parser';
 /**
  * Normalizes any token identifier format to TokenInstanceKey
  *
@@ -47,12 +48,15 @@ export declare function normalizeToTokenInstanceKey(tokenId: TokenId): TokenInst
  */
 export declare function isTokenInstanceKey(tokenId: TokenId): tokenId is TokenInstanceKey;
 /**
- * Type guard to check if a TokenId is a TokenClassKey object
+ * Strict type guard that validates all TokenClassKey fields are non-empty strings.
  *
- * @param tokenId Token identifier to check
- * @returns True if tokenId is a TokenClassKey object (no instance field)
+ * 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 declare function isTokenClassKey(tokenId: TokenId): tokenId is TokenClassKey;
+export { isTokenClassKeyStrict };
 /**
  * Type guard to check if a TokenId is a string
  *
@@ -60,47 +64,6 @@ export declare function isTokenClassKey(tokenId: TokenId): tokenId is TokenClass
  * @returns True if tokenId is a string
  */
 export declare function isTokenIdString(tokenId: TokenId): tokenId is string;
-/**
- * Converts a TokenInstanceKey to pipe-separated string format
- *
- * @param tokenInstance TokenInstanceKey to convert
- * @returns String in format "collection|category|type|additionalKey|instance"
- *
- * @example
- * ```typescript
- * const tokenInstance = {
- *   collection: "GALA",
- *   category: "Unit",
- *   type: "none",
- *   additionalKey: "none",
- *   instance: "0"
- * };
- *
- * const result = tokenInstanceKeyToString(tokenInstance);
- * // → "GALA|Unit|none|none|0"
- * ```
- */
-export declare function tokenInstanceKeyToString(tokenInstance: TokenInstanceKey): string;
-/**
- * Converts a TokenClassKey to pipe-separated string format (without instance)
- *
- * @param tokenClass TokenClassKey to convert
- * @returns String in format "collection|category|type|additionalKey"
- *
- * @example
- * ```typescript
- * const tokenClass = {
- *   collection: "Token",
- *   category: "Unit",
- *   type: "UNI",
- *   additionalKey: "eth:9401b171307bE656f00F9e18DF756643FD3a91dE"
- * };
- *
- * const result = tokenClassKeyToString(tokenClass);
- * // → "Token|Unit|UNI|eth:9401b171307bE656f00F9e18DF756643FD3a91dE"
- * ```
- */
-export declare function tokenClassKeyToString(tokenClass: TokenClassKey): string;
 /**
  * Validates that a TokenId has all required fields
  *