@gala-chain/launchpad-sdk 8.1.0 → 9.0.0-rc.1

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

@@ -7,13 +7,13 @@
  * - 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.
+ * Plain strings like "GALA" are not token formats: a caller detects the delimiter
+ * (`isPipeDelimited` / `isDollarDelimited`) and parses with the matching parser.
+ * The object guard for a token class key is gala-core-sdk's `isTokenClassKey`.
  *
  * @packageDocumentation
  */
-import type { TokenClassKey } from '../types/common';
+import type { GalaChainTokenClassKey } from '@gala-chain/gala-core-sdk';
 /**
  * PERFORMANCE CHARACTERISTICS:
  *
@@ -21,10 +21,6 @@ import type { TokenClassKey } from '../types/common';
  * - 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';
@@ -36,61 +32,12 @@ import type { TokenClassKey } from '../types/common';
  * }
  * ```
  */
-/**
- * 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;
+export declare function parsePipeDelimitedToken(token: string): GalaChainTokenClassKey;
 /**
  * REVERSE-PARSING ALGORITHM FOR DOLLAR-DELIMITED TOKENS
  *
@@ -140,10 +87,9 @@ export declare function parsePipeDelimitedToken(token: string): TokenClassKey;
  * - Last 3 parts (from right): category, type, additionalKey
  * - Everything else: collection
  *
- * @internal Used by parseToken()
  * @throws ValidationError if format is invalid
  */
-export declare function parseDollarDelimitedToken(token: string): TokenClassKey;
+export declare function parseDollarDelimitedToken(token: string): GalaChainTokenClassKey;
 /**
  * Check if token string is in pipe-delimited format
  *
@@ -165,71 +111,4 @@ export declare function isPipeDelimited(token: string): boolean;
  * ```
  */
 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/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;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,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAGtE;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"}
+{"version":3,"file":"token-parser.d.ts","sourceRoot":"","sources":["../../src/utils/token-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAOxE;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAG7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAG/E;AAGD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD"}

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

@@ -4,7 +4,7 @@
  * @category Utilities
  * @since 6.6.0
  */
-import type { TokenClassKey, TokenInstanceKey } from '../types/common';
+import type { GalaChainTokenClassKey, GalaChainTokenInstanceKey } from '@gala-chain/gala-core-sdk';
 /**
  * Convert a TokenClassKey to pipe-delimited string format
  *
@@ -37,7 +37,7 @@ import type { TokenClassKey, TokenInstanceKey } from '../types/common';
  *
  * @since 6.6.0
  */
-export declare function stringifyTokenClassKey(token: TokenClassKey): string;
+export declare function stringifyTokenClassKey(token: GalaChainTokenClassKey): string;
 /**
  * Convert a TokenInstanceKey to pipe-delimited string format (with instance)
  *
@@ -63,7 +63,7 @@ export declare function stringifyTokenClassKey(token: TokenClassKey): string;
  *
  * @since 6.6.0
  */
-export declare function stringifyTokenInstanceKey(token: TokenInstanceKey): string;
+export declare function stringifyTokenInstanceKey(token: GalaChainTokenInstanceKey): string;
 /**
  * Convert either TokenClassKey or TokenInstanceKey to string
  *
@@ -88,7 +88,7 @@ export declare function stringifyTokenInstanceKey(token: TokenInstanceKey): stri
  *
  * @since 6.6.0
  */
-export declare function stringifyToken(token: TokenClassKey | TokenInstanceKey): string;
+export declare function stringifyToken(token: GalaChainTokenClassKey | GalaChainTokenInstanceKey): string;
 /**
  * Convert TokenClassKey to dollar-delimited string format
  *
@@ -113,7 +113,7 @@ export declare function stringifyToken(token: TokenClassKey | TokenInstanceKey):
  *
  * @since 6.7.0
  */
-export declare function stringifyTokenClassKeyDollar(token: TokenClassKey): string;
+export declare function stringifyTokenClassKeyDollar(token: GalaChainTokenClassKey): string;
 /**
  * Convert TokenInstanceKey to dollar-delimited string format (with instance)
  *
@@ -139,7 +139,7 @@ export declare function stringifyTokenClassKeyDollar(token: TokenClassKey): stri
  *
  * @since 6.7.0
  */
-export declare function stringifyTokenInstanceKeyDollar(token: TokenInstanceKey): string;
+export declare function stringifyTokenInstanceKeyDollar(token: GalaChainTokenInstanceKey): string;
 /**
  * Convert TokenClassKey to dollar-delimited string format with prefix
  *
@@ -163,5 +163,5 @@ export declare function stringifyTokenInstanceKeyDollar(token: TokenInstanceKey)
  *
  * @since 6.7.0
  */
-export declare function stringifyTokenClassKeyDollarPrefixed(token: TokenClassKey): string;
+export declare function stringifyTokenClassKeyDollarPrefixed(token: GalaChainTokenClassKey): string;
 //# sourceMappingURL=token-stringification.d.ts.map

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAEjF"}
+{"version":3,"file":"token-stringification.d.ts","sourceRoot":"","sources":["../../src/utils/token-stringification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAE5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,yBAAyB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,sBAAsB,GAAG,yBAAyB,GAAG,MAAM,CAKhG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,yBAAyB,GAAG,MAAM,CAExF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAE1F"}

package/dist/utils/tokenNameNormalizer.d.ts

@@ -35,8 +35,8 @@ 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.
+ * Used by the cache services (AbstractCacheService) for case-insensitive lookups of token
+ * symbols and tokenIds.
  *
  * Current normalizations:
  * - `.trim()` - Remove leading/trailing whitespace

package/dist/utils/tokenNormalizer.d.ts

@@ -4,8 +4,8 @@
  * 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';
+import { type GalaChainTokenClassKey, type GalaChainTokenInstanceKey } from '@gala-chain/gala-core-sdk';
+import type { TokenId } from '../types/common';
 /**
  * Normalizes any token identifier format to TokenInstanceKey
  *
@@ -39,31 +39,7 @@ import { isTokenClassKey as isTokenClassKeyStrict } from './token-parser';
  * // → 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;
+export declare function normalizeToTokenInstanceKey(tokenId: TokenId): GalaChainTokenInstanceKey;
 /**
  * Validates that a TokenId has all required fields
  *
@@ -94,7 +70,7 @@ export declare function validateTokenId(tokenId: TokenId): void;
  *
  * @since 3.32.0
  */
-export declare function parseVaultAddressToTokenClassKey(vaultAddress: string): TokenClassKey;
+export declare function parseVaultAddressToTokenClassKey(vaultAddress: string): GalaChainTokenClassKey;
 /**
  * Parses a vault address into a TokenInstanceKey
  *
@@ -115,7 +91,7 @@ export declare function parseVaultAddressToTokenClassKey(vaultAddress: string):
  *
  * @since 3.32.0
  */
-export declare function parseVaultAddressToTokenInstance(vaultAddress: string): TokenInstanceKey;
+export declare function parseVaultAddressToTokenInstance(vaultAddress: string): GalaChainTokenInstanceKey;
 /**
  * Extracts the launchpad token symbol (carried in `type` of the shared `Token` collection) from a
  * launchpad vault address. Throws for any other collection: a symbol cannot be derived from a class key.

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

@@ -1 +1 @@
-{"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;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAYxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAMjE"}
+{"version":3,"file":"tokenNormalizer.d.ts","sourceRoot":"","sources":["../../src/utils/tokenNormalizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAO/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,yBAAyB,CAsEvF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CActD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,GAAG,sBAAsB,CAG7F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,GAAG,yBAAyB,CAMhG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAYxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAMjE"}

package/dist/utils/unique-key-generator.d.ts

@@ -1,147 +1,20 @@
 /**
- * GalaChain Unique Operation Key Generator
+ * The uniqueKey of a launchpad bundle trade (BundleService buy/sell).
  *
- * Generates unique identifiers for GalaChain bundle transactions and operations
- * that require idempotency keys. Consolidated from 14+ duplicated patterns across
- * transfer and lock/unlock operations.
+ * A generic GalaChain uniqueKey is gala-core-sdk's `createUniqueKey(prefix)` (CSPRNG,
+ * `<prefix><uuid v4>`); launchpad-sdk 9.0 removed its own `generateUniqueKey`, which duplicated it.
  *
  * @category Utilities
  * @since 6.14.0
  */
 /**
- * Generate a unique operation key for GalaChain bundle transactions.
- *
- * Creates a deterministic yet unique identifier combining:
- * - Timestamp (millisecond precision)
- * - Cryptographically random suffix (derived from a UUID v4, ~104 bits of entropy)
- *
- * Format: `galaconnect-operation-{timestamp}_{randomSuffix}`
- *
- * Used for idempotency across:
- * - Token transfers (uniqueKey parameter)
- * - Token locks/unlocks (uniqueKey parameter)
- * - Token burns (uniqueKey parameter)
- * - Any operation requiring request deduplication
- *
- * @returns Unique operation key in format `galaconnect-operation-{timestamp}_{randomSuffix}`
- *
- * @example Basic usage
- * ```typescript
- * import { generateUniqueKey } from '@gala-chain/launchpad-sdk';
- *
- * const key = generateUniqueKey();
- * console.log(key); // 'galaconnect-operation-1735857234567_abc123'
- *
- * // Use in transfer operation
- * await sdk.transferGala({
- *   recipientAddress: 'eth|0x...',
- *   amount: '100',
- *   uniqueKey: generateUniqueKey()
- * });
- * ```
- *
- * @example With explicit key
- * ```typescript
- * // For operations where you control the idempotency key
- * const operationKey = `my-operation-${Date.now()}`;
- * await sdk.transferToken({
- *   to: 'eth|0x...',
- *   tokenName: 'anime',
- *   amount: '1000',
- *   uniqueKey: operationKey
- * });
- * ```
- *
- * @see {@link https://docs.galachain.com/idempotency GalaChain Idempotency}
- */
-export declare function generateUniqueKey(): string;
-/**
- * Generate a unique operation key for GalaSwap bundle (buy/sell) transactions.
- *
- * Same shape and entropy guarantees as {@link generateUniqueKey}, but uses the
- * `galaswap-operation-` prefix GalaSwap trade operations are identified by
- * (`UNIQUE_KEY_CONSTRAINT.PATTERN` accepts either prefix).
+ * Generate a unique operation key for GalaSwap bundle (buy/sell) transactions:
+ * `galaswap-operation-{timestamp}_{randomSuffix}`, the suffix 26 hex digits of a UUID v4
+ * (~104 bits; never `Math.random()`: a collision would let GalaChain treat two different trades as
+ * retries of one), within `UNIQUE_KEY_CONSTRAINT.MAX_LENGTH` (64) and its `PATTERN`.
  *
  * @returns Unique operation key in format `galaswap-operation-{timestamp}_{randomSuffix}`
  * @since 6.14.0
  */
 export declare function generateSwapOperationKey(): string;
-/**
- * Generate unique operation key with UUID, timestamp, and wallet address
- *
- * Creates a unique identifier for GalaSwap operations combining:
- * - Prefix (customizable, defaults to 'galaswap-operation')
- * - UUID v4 for global uniqueness
- * - Timestamp (millisecond precision)
- * - Wallet address for context
- *
- * Format: `{prefix}-${uuid}-${timestamp}-${walletAddress}`
- *
- * Used for idempotent GalaSwap operations including:
- * - Liquidity additions (add/remove)
- * - Swap executions
- * - Fee collections
- * - Bundle transactions
- *
- * @param walletAddress The wallet address associated with the operation (required)
- * @param prefix Optional custom prefix (defaults to 'galaswap-operation')
- * @returns Unique operation key combining UUID, timestamp, and wallet address
- *
- * @example Basic usage with default prefix
- * ```typescript
- * import { generateOperationKey } from '@gala-chain/launchpad-sdk';
- *
- * const operationKey = generateOperationKey('eth|0x1234567890abcdef...');
- * console.log(operationKey);
- * // 'galaswap-operation-550e8400-e29b-41d4-a716-446655440000-1735857234567-eth|0x1234...'
- * ```
- *
- * @example With custom prefix
- * ```typescript
- * import { generateOperationKey } from '@gala-chain/launchpad-sdk';
- *
- * const operationKey = generateOperationKey(
- *   'eth|0x1234567890abcdef...',
- *   'custom-swap'
- * );
- * console.log(operationKey);
- * // 'custom-swap-550e8400-e29b-41d4-a716-446655440000-1735857234567-eth|0x1234...'
- * ```
- *
- * @example With an operation that accepts a caller-supplied uniqueKey
- * ```typescript
- * import { generateOperationKey } from '@gala-chain/launchpad-sdk';
- *
- * // transferGala/transferToken/lockToken/unlockToken accept an optional
- * // uniqueKey for idempotency (sdk.dex.* writes generate their own internally).
- * const result = await sdk.transferGala({
- *   recipientAddress,
- *   amount: '100',
- *   uniqueKey: generateOperationKey(walletAddress),
- * });
- * ```
- *
- * @example Handling operation idempotency
- * ```typescript
- * // sdk.dex.swaps.swap() generates its own durable uniqueKey and returns it on the
- * // SubmittedTransaction, so recovering an in-flight swap replays confirmation instead
- * // of resubmitting with a caller-supplied key:
- * let submitted;
- * try {
- *   submitted = await sdk.dex.swaps.swap('GALA', 'GUSDC', 3000, {
- *     exactIn: '100',
- *     amountOutMinimum: '95',
- *   });
- *   await submitted.confirm();
- * } catch (error) {
- *   if (submitted) {
- *     // Recover by uniqueKey - does not resubmit, avoids duplicate execution
- *     await sdk.dex.swaps.confirmSwap(submitted.uniqueKey);
- *   }
- * }
- * ```
- *
- * @since 3.50.0
- */
-export declare function generateOperationKey(walletAddress: string, prefix?: string): string;
 //# sourceMappingURL=unique-key-generator.d.ts.map

package/dist/utils/unique-key-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unique-key-generator.d.ts","sourceRoot":"","sources":["../../src/utils/unique-key-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoBH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAM1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,MAA6B,GACpC,MAAM,CAIR"}
+{"version":3,"file":"unique-key-generator.d.ts","sourceRoot":"","sources":["../../src/utils/unique-key-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAIjD"}

package/dist/utils/validation-helpers.d.ts

@@ -7,7 +7,7 @@
  * @category Utilities
  * @since 3.6.2
  */
-import { type TokenNameConstraint } from '../types/constraints';
+import type { TokenNameConstraint } from '../types/constraints';
 import { isEmptyValue as isEmptyValuePrimitive, isNonEmptyString as isNonEmptyStringPrimitive, isNullish as isNullishPrimitive } from './primitives';
 /**
  * Pagination bounds structure (required fields)
@@ -275,10 +275,8 @@ export interface MutualExclusivityResult {
 /**
  * Validates that exactly one of two parameters is provided (mutual exclusivity)
  *
- * Consolidates 12+ instances of identical validation logic found across services:
- * - PriceHistoryService: tokenName XOR tokenId (lines 451-470)
- * - DexService: Similar patterns with token identification
- * - Other services: Scattered mutual exclusivity validation
+ * Consolidates the mutual-exclusivity checks the services used to repeat (e.g. tokenName XOR
+ * tokenId for a token identification).
  *
  * ## Use Cases
  *
@@ -322,7 +320,7 @@ export interface MutualExclusivityResult {
  *
  * @example Token identifier validation
  * ```typescript
- * // PriceHistoryService.fetchAllPriceHistory() - replaces 20-line validation method
+ * // a method that takes a token by name or by id, never both
  * const { hasA } = validateMutualExclusive(options, 'tokenName', 'tokenId', {
  *   description: 'token identifier'
  * });
@@ -338,89 +336,48 @@ export declare function validateMutualExclusive(obj: Record<string, unknown>, fi
 }): MutualExclusivityResult;
 export type { TokenNameConstraint };
 /**
- * Validates a launchpad token name using configurable constraints
+ * Validates a launchpad token name against the rule of the route it is sent to
  *
- * Consolidates duplicate token name validation logic found across multiple DTO files:
- * - streaming.dto.ts (validateStreamingTokenName)
- * - content-flag.dto.ts (validateFlagTokenName)
- * - comment.dto.ts (inline validation)
- * - ban.dto.ts (inline validation)
- * - moderator.dto.ts (inline validation)
+ * There is no default constraint: the rule is the backend route's (`TOKEN_NAME_DTO_CONSTRAINT`,
+ * `TOKEN_NAME_PATH_CONSTRAINT`, ... in `types/constraints`), so the caller names it.
  *
- * ## Usage
- *
- * ### With default constraints (3-20 alphanumeric)
- * ```typescript
- * validateLaunchpadTokenName(tokenName); // Uses LAUNCHPAD_TOKEN_NAME_CONSTRAINT
- * ```
- *
- * ### With custom constraints from DTO
  * ```typescript
- * import { STREAMING_CONSTRAINTS } from '../types/streaming.dto';
- * validateLaunchpadTokenName(tokenName, 'tokenName', STREAMING_CONSTRAINTS.TOKEN_NAME);
- * ```
- *
- * ### With custom field name for error messages
- * ```typescript
- * validateLaunchpadTokenName(options.tokenName, 'tokenName', BAN_CONSTRAINTS.TOKEN_NAME);
+ * validateLaunchpadTokenName(options.tokenName, 'tokenName', TOKEN_NAME_DTO_CONSTRAINT);
  * ```
  *
  * @param tokenName - Token name to validate
- * @param field - Field name for error messages (defaults to 'tokenName')
- * @param constraint - Token name constraint configuration (defaults to LAUNCHPAD_TOKEN_NAME_CONSTRAINT)
+ * @param field - Field name for error messages
+ * @param constraint - The route's token name constraint
  * @throws {ValidationError} If token name is invalid (empty, too short, too long, or invalid format)
  *
  * @since 6.4.0
  */
-export declare function validateLaunchpadTokenName(tokenName: string, field?: string, constraint?: TokenNameConstraint): void;
+export declare function validateLaunchpadTokenName(tokenName: string, field: string, constraint: TokenNameConstraint): void;
 /**
  * Validates an optional token name (allows undefined/null, but validates if present)
  *
  * Use this for optional token name fields that should be validated when provided.
- * Consolidates duplicate logic from tokenNameValidator.ts.
  *
  * @param tokenName - The token name to validate (may be undefined/null)
- * @param field - The field name for error messages (default: 'tokenName')
- * @param constraint - Token name constraint (default: LAUNCHPAD_TOKEN_NAME_CONSTRAINT)
+ * @param field - The field name for error messages
+ * @param constraint - The route's token name constraint
  * @throws {ValidationError} If token name is provided but invalid
  *
- * @example
- * ```typescript
- * // No error - undefined is allowed
- * validateOptionalTokenName(undefined);
- *
- * // Throws ValidationError - provided but invalid
- * validateOptionalTokenName('ab');
- *
- * // Success - valid token name
- * validateOptionalTokenName('myToken123');
- * ```
- *
  * @since 6.12.0
  */
-export declare function validateOptionalTokenName(tokenName: unknown, field?: string, constraint?: TokenNameConstraint): void;
+export declare function validateOptionalTokenName(tokenName: unknown, field: string, constraint: TokenNameConstraint): void;
 /**
  * Checks if a token name is valid without throwing
  *
  * Use this for conditional checks where you don't want exceptions.
- * Consolidates duplicate logic from tokenNameValidator.ts.
  *
  * @param tokenName - The token name to check
- * @param constraint - Token name constraint (default: LAUNCHPAD_TOKEN_NAME_CONSTRAINT)
+ * @param constraint - The route's token name constraint
  * @returns true if valid, false otherwise
  *
- * @example
- * ```typescript
- * if (isValidTokenName(userInput)) {
- *   // Proceed with token lookup
- * } else {
- *   // Show validation error to user
- * }
- * ```
- *
  * @since 6.12.0
  */
-export declare function isValidTokenName(tokenName: unknown, constraint?: TokenNameConstraint): tokenName is string;
+export declare function isValidTokenName(tokenName: unknown, constraint: TokenNameConstraint): tokenName is string;
 /**
  * Validates a token name with constraint-specific error messages
  *
@@ -428,19 +385,19 @@ export declare function isValidTokenName(tokenName: unknown, constraint?: TokenN
  * This is the recommended function for service methods.
  *
  * @param tokenName - Token name to validate
- * @param field - Field name for error messages (default: 'tokenName')
- * @param constraint - Token name constraint with MIN_LENGTH, MAX_LENGTH, PATTERN
+ * @param field - Field name for error messages
+ * @param constraint - The route's token name constraint
  * @throws {ValidationError} If token name is invalid
  *
  * @example
  * ```typescript
- * // Throws: "tokenName must be 3-20 alphanumeric characters"
- * validateTokenName('ab', 'tokenName', LAUNCHPAD_TOKEN_NAME_CONSTRAINT);
+ * // Throws: "tokenName must be 1-20 letters and digits"
+ * validateTokenName('my-token', 'tokenName', TOKEN_NAME_DTO_CONSTRAINT);
  * ```
  *
  * @since 6.12.0
  */
-export declare function validateTokenName(tokenName: unknown, field?: string, constraint?: TokenNameConstraint): void;
+export declare function validateTokenName(tokenName: unknown, field: string, constraint: TokenNameConstraint): void;
 /**
  * Field validator configuration for structural type guards
  *