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

package/dist/bridge/utils/retry.d.ts

@@ -1,112 +0,0 @@
-/**
- * Retry Utility
- *
- * Provides exponential backoff retry logic for transient network failures.
- */
-/**
- * Configuration options for retry behavior.
- */
-export interface RetryOptions {
-    /**
-     * Maximum number of retry attempts (default: 3)
-     */
-    maxRetries?: number;
-    /**
-     * Initial delay in milliseconds before first retry (default: 1000)
-     */
-    initialDelayMs?: number;
-    /**
-     * Maximum delay in milliseconds between retries (default: 30000)
-     */
-    maxDelayMs?: number;
-    /**
-     * Multiplier for exponential backoff (default: 2)
-     */
-    backoffMultiplier?: number;
-    /**
-     * Jitter factor to add randomness to delays (0-1, default: 0.1)
-     * Helps prevent thundering herd problems.
-     */
-    jitterFactor?: number;
-    /**
-     * Custom function to determine if an error should trigger a retry.
-     * Default: retries on network errors and 5xx/429 status codes.
-     */
-    shouldRetry?: (error: unknown, attempt: number) => boolean;
-    /**
-     * Callback invoked before each retry attempt.
-     * Useful for logging or metrics.
-     */
-    onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
-}
-/**
- * Determines if an error is retryable based on its characteristics.
- *
- * @param error - The error to evaluate
- * @returns True if the error should trigger a retry
- */
-export declare function isRetryableError(error: unknown): boolean;
-/**
- * Calculates the delay before the next retry attempt using exponential backoff with jitter.
- *
- * @param attempt - Current attempt number (1-based)
- * @param options - Retry configuration options
- * @returns Delay in milliseconds
- */
-export declare function calculateRetryDelay(attempt: number, options: Required<Omit<RetryOptions, 'onRetry' | 'shouldRetry'>>): number;
-/**
- * Executes an async function with exponential backoff retry logic.
- *
- * @param fn - The async function to execute
- * @param options - Retry configuration options
- * @returns The result of the function
- * @throws The last error if all retries are exhausted
- *
- * @example
- * ```typescript
- * const result = await withRetry(
- *   () => fetch('https://api.example.com/data'),
- *   {
- *     maxRetries: 3,
- *     onRetry: (error, attempt, delay) => {
- *       console.log(`Retry ${attempt} after ${delay}ms: ${error}`);
- *     },
- *   }
- * );
- * ```
- */
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-/**
- * Creates a retry wrapper with pre-configured options.
- *
- * @param defaultOptions - Default retry options for all calls
- * @returns A configured retry function
- *
- * @example
- * ```typescript
- * const apiRetry = createRetryWrapper({
- *   maxRetries: 5,
- *   initialDelayMs: 500,
- * });
- *
- * const result = await apiRetry(() => fetchData());
- * ```
- */
-export declare function createRetryWrapper(defaultOptions: RetryOptions): <T>(fn: () => Promise<T>, overrideOptions?: RetryOptions) => Promise<T>;
-/**
- * Simple delay utility for async operations.
- *
- * @param ms - Delay duration in milliseconds
- * @returns Promise that resolves after the specified delay
- *
- * @example
- * ```typescript
- * // Wait 1 second before continuing
- * await delay(1000);
- *
- * // Wait before registration
- * await delay(REGISTRATION_DELAY_MS);
- * ```
- */
-export declare function delay(ms: number): Promise<void>;
-//# sourceMappingURL=retry.d.ts.map

package/dist/bridge/utils/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/bridge/utils/retry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAE3D;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtE;AAwCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAiCxD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,aAAa,CAAC,CAAC,GAC/D,MAAM,CAWR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,CAAC,CAAC,CAyCZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,YAAY,IACrD,CAAC,EAAE,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,kBAAkB,YAAY,KAAG,OAAO,CAAC,CAAC,CAAC,CAG7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C"}

package/dist/bridge/utils/strategyDelegation.d.ts

@@ -1,126 +0,0 @@
-/**
- * Strategy Delegation Helpers
- *
- * DRY utilities for delegating balance operations to typed strategies.
- * Eliminates repetitive assertStrategyExists() + cast + delegate patterns
- * across BridgeService balance methods.
- *
- * @module bridge/utils/strategyDelegation
- */
-import type { BridgeStrategy } from '../strategies/BridgeStrategy.js';
-import type { EthereumBridgeStrategy } from '../strategies/EthereumBridgeStrategy.js';
-import type { SolanaBridgeStrategy } from '../strategies/SolanaBridgeStrategy.js';
-import type { ExternalNetwork } from '../types/index.js';
-import type { BridgeFeeEstimate, BridgeStatus } from '../types/index.js';
-import type { GalaConnectClient } from '../GalaConnectClient.js';
-import type { TokenMetadataResolver } from './tokenMetadataResolver.js';
-/**
- * Get Ethereum strategy with type assertion.
- *
- * Combines strategy existence check with type cast in a single call.
- * Use this instead of assertStrategyExists() + manual cast.
- *
- * @param strategies - Strategy map from BridgeService
- * @param customError - Optional custom error message
- * @returns Typed EthereumBridgeStrategy
- * @throws Error if Ethereum strategy not configured
- *
- * @example
- * ```typescript
- * const ethStrategy = getEthereumStrategy(this.strategies);
- * const balance = await ethStrategy.getEthereumTokenBalance(symbol, address);
- * ```
- */
-export declare function getEthereumStrategy(strategies: Map<ExternalNetwork, BridgeStrategy>, customError?: string): EthereumBridgeStrategy;
-/**
- * Get Solana strategy with type assertion.
- *
- * Combines strategy existence check with type cast in a single call.
- * Use this instead of assertStrategyExists() + manual cast.
- *
- * @param strategies - Strategy map from BridgeService
- * @param customError - Optional custom error message
- * @returns Typed SolanaBridgeStrategy
- * @throws Error if Solana strategy not configured
- *
- * @example
- * ```typescript
- * const solStrategy = getSolanaStrategy(this.strategies);
- * const balance = await solStrategy.getSolanaTokenBalance(symbol, address);
- * ```
- */
-export declare function getSolanaStrategy(strategies: Map<ExternalNetwork, BridgeStrategy>, customError?: string): SolanaBridgeStrategy;
-/**
- * Resolve target address with wallet fallback.
- *
- * A common pattern in balance methods: use provided address or fall back
- * to strategy's configured wallet address.
- *
- * @param providedAddress - Optional user-provided address
- * @param strategy - Strategy instance with getWalletAddress()
- * @returns Resolved address (user-provided or wallet default)
- *
- * @example
- * ```typescript
- * const targetAddress = resolveTargetAddress(address, ethStrategy);
- * // Returns address if provided, otherwise ethStrategy.getWalletAddress()
- * ```
- */
-export declare function resolveTargetAddress(providedAddress: string | undefined, strategy: {
-    getWalletAddress(): string;
-}): string;
-/**
- * Fetch and normalize a bridge fee estimate for a configured external chain.
- *
- * @param client - GalaConnect bridge client.
- * @param resolver - Token metadata resolver.
- * @param chainId - External chain identifier.
- * @param tokenSymbol - Token symbol.
- * @param amount - Amount being estimated.
- * @returns Normalized bridge fee estimate.
- *
- * @example
- * ```typescript
- * const estimate = await estimateStrategyFee(client, resolver, 'Ethereum', 'GALA', '1');
- * ```
- */
-export declare function estimateStrategyFee(client: GalaConnectClient, resolver: TokenMetadataResolver, chainId: string, tokenSymbol: string, amount: string): Promise<BridgeFeeEstimate>;
-/**
- * Fetch a normalized bridge transaction status.
- *
- * @param client - GalaConnect bridge client.
- * @param transactionHash - Transaction hash.
- * @returns Parsed bridge status.
- *
- * @example
- * ```typescript
- * const status = await getStrategyStatus(client, '0xabc');
- * ```
- */
-export declare function getStrategyStatus(client: GalaConnectClient, transactionHash: string): Promise<BridgeStatus>;
-/**
- * Return configured bridge token symbols.
- *
- * @param tokenConfigs - Normalized token configuration map.
- * @returns Configured token symbols.
- *
- * @example
- * ```typescript
- * const symbols = getConfiguredTokenSymbols(tokenConfigs);
- * ```
- */
-export declare function getConfiguredTokenSymbols(tokenConfigs: ReadonlyMap<string, unknown>): string[];
-/**
- * Check whether a normalized token configuration map supports a symbol.
- *
- * @param tokenConfigs - Normalized token configuration map.
- * @param tokenSymbol - Token symbol to check.
- * @returns Whether the symbol is configured.
- *
- * @example
- * ```typescript
- * const supported = isConfiguredToken(tokenConfigs, 'GALA');
- * ```
- */
-export declare function isConfiguredToken(tokenConfigs: ReadonlyMap<string, unknown>, tokenSymbol: string): boolean;
-//# sourceMappingURL=strategyDelegation.d.ts.map

package/dist/bridge/utils/strategyDelegation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategyDelegation.d.ts","sourceRoot":"","sources":["../../../src/bridge/utils/strategyDelegation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAqB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAUxE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,GAAG,CAAC,eAAe,EAAE,cAAc,CAAC,EAChD,WAAW,CAAC,EAAE,MAAM,GACnB,sBAAsB,CAMxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,GAAG,CAAC,eAAe,EAAE,cAAc,CAAC,EAChD,WAAW,CAAC,EAAE,MAAM,GACnB,oBAAoB,CAMtB;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,QAAQ,EAAE;IAAE,gBAAgB,IAAI,MAAM,CAAA;CAAE,GACvC,MAAM,CAER;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iBAAiB,CAAC,CAQ5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,iBAAiB,EACzB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,YAAY,CAAC,CAGvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAE9F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,WAAW,EAAE,MAAM,GAClB,OAAO,CAET"}

package/dist/bridge/utils/tokenIdUtils.d.ts

@@ -1,86 +0,0 @@
-/**
- * Token ID Utilities
- *
- * Functions for parsing and resolving TokenId to symbol and TokenClassKey.
- * Re-exports and builds upon the shared token-parser utilities.
- */
-import type { TokenClassKey, TokenId } from '../../types/common.js';
-/**
- * Result of parsing a TokenId
- */
-export interface ParsedTokenId {
-    /** Full TokenClassKey structure */
-    tokenClassKey: TokenClassKey;
-    /** Pipe-delimited string format (e.g., "GALA|Unit|none|none") */
-    stringified: string;
-}
-/**
- * Check if a value is a TokenClassKey object
- *
- * Re-exports the shared isTokenClassKey from token-parser.
- *
- * @param value - Value to check
- * @returns True if the value is a TokenClassKey object
- */
-export declare function isTokenClassKey(value: unknown): value is TokenClassKey;
-/**
- * Parse a pipe-delimited token string to TokenClassKey
- *
- * Delegates to the shared parsePipeDelimitedToken from token-parser.
- *
- * @param tokenString - Pipe-delimited string (e.g., "GALA|Unit|none|none")
- * @returns TokenClassKey object
- * @throws Error if string format is invalid
- *
- * @example
- * ```typescript
- * const key = parseTokenString('GALA|Unit|none|none');
- * // { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
- * ```
- */
-export declare function parseTokenString(tokenString: string): TokenClassKey;
-/**
- * Stringify a TokenClassKey to pipe-delimited format
- *
- * Delegates to centralized stringifyTokenClassKey from utils/token-stringification.ts
- *
- * @param key - TokenClassKey object
- * @returns Pipe-delimited string
- *
- * @example
- * ```typescript
- * const str = stringifyTokenClassKey({
- *   collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none'
- * });
- * // "GALA|Unit|none|none"
- * ```
- */
-export declare function stringifyTokenClassKey(key: TokenClassKey): string;
-/**
- * Parse a TokenId (string or object) to get TokenClassKey
- *
- * Accepts:
- * - Pipe-delimited string: "GALA|Unit|none|none"
- * - TokenClassKey object: { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
- *
- * NOTE: This function does NOT extract symbol. Use BridgeableTokenService to look up
- * token metadata (symbol, decimals, contract address) by tokenId.
- *
- * @param tokenId - TokenId in any supported format
- * @returns Parsed result with tokenClassKey and stringified form
- * @throws Error if tokenId format is invalid
- *
- * @example String input
- * ```typescript
- * const result = parseTokenId('GALA|Unit|none|none');
- * // { tokenClassKey: { collection: 'GALA', ... }, stringified: 'GALA|Unit|none|none' }
- * ```
- *
- * @example Object input
- * ```typescript
- * const result = parseTokenId({ collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' });
- * // { tokenClassKey: { collection: 'GALA', ... }, stringified: 'GALA|Unit|none|none' }
- * ```
- */
-export declare function parseTokenId(tokenId: TokenId): ParsedTokenId;
-//# sourceMappingURL=tokenIdUtils.d.ts.map

package/dist/bridge/utils/tokenIdUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenIdUtils.d.ts","sourceRoot":"","sources":["../../../src/bridge/utils/tokenIdUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAC,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAOnE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAEnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAgB5D"}

package/dist/bridge/utils/tokenMath.d.ts

@@ -1,39 +0,0 @@
-/**
- * Token Math Utilities
- *
- * Utilities for converting between decimal and base unit representations.
- */
-/**
- * Convert a decimal amount to base units (smallest denomination)
- *
- * @param amount - The decimal amount as a string (e.g., "1.5")
- * @param decimals - The number of decimal places
- * @returns The amount in base units as a bigint
- * @throws Error if the amount is invalid or cannot be represented with the given decimals
- */
-export declare function toBaseUnits(amount: string, decimals: number): bigint;
-/**
- * Convert base units to a decimal string
- *
- * @param amount - The amount in base units
- * @param decimals - The number of decimal places
- * @returns The decimal string representation with trailing zeros removed
- */
-export declare function fromBaseUnits(amount: bigint, decimals: number): string;
-/**
- * Format a token amount for display
- *
- * @param amount - The decimal amount as a string
- * @param maxDecimals - Maximum decimals to display (default: 6)
- * @returns Formatted string with appropriate precision
- */
-export declare function formatTokenAmount(amount: string, maxDecimals?: number): string;
-/**
- * Compare two token amounts
- *
- * @param a - First amount
- * @param b - Second amount
- * @returns -1 if a < b, 0 if a == b, 1 if a > b
- */
-export declare function compareAmounts(a: string, b: string): -1 | 0 | 1;
-//# sourceMappingURL=tokenMath.d.ts.map

package/dist/bridge/utils/tokenMath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenMath.d.ts","sourceRoot":"","sources":["../../../src/bridge/utils/tokenMath.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiBpE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtE;AAQD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM,CAkBzE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAK/D"}

package/dist/bridge/utils/tokenMetadataResolver.d.ts

@@ -1,97 +0,0 @@
-/**
- * Token Metadata Resolver
- *
- * Shared utility for resolving bridge token metadata.
- * Used by both EthereumBridgeStrategy and SolanaBridgeStrategy.
- *
- * @module bridge/utils/tokenMetadataResolver
- */
-import type { GalaConnectClient } from '../GalaConnectClient.js';
-import type { BridgeTokenMetadata } from '../types/index.js';
-/**
- * Configuration for TokenMetadataResolver
- */
-export interface TokenMetadataResolverConfig {
-    /** GalaConnect client for API lookups */
-    galaConnectClient: GalaConnectClient;
-}
-/**
- * Token Metadata Resolver
- *
- * Provides cached token metadata resolution with fallback to API lookup.
- * This consolidates duplicate `getTokenMetadata()` implementations from
- * EthereumBridgeStrategy and SolanaBridgeStrategy.
- *
- * Resolution order:
- * 1. In-memory cache (fastest)
- * 2. Static metadata for well-known tokens (GALA, GWETH, etc.)
- * 3. GalaConnect API lookup (slowest, cached after)
- *
- * @example
- * ```typescript
- * const resolver = new TokenMetadataResolver({
- *   galaConnectClient: client,
- * });
- *
- * const metadata = await resolver.getTokenMetadata('GALA');
- * console.log(metadata.decimals); // 8
- * ```
- */
-export declare class TokenMetadataResolver {
-    private readonly galaConnectClient;
-    private readonly cache;
-    constructor(config: TokenMetadataResolverConfig);
-    /**
-     * Get token metadata for a symbol.
-     *
-     * Checks cache first, then static metadata, then API.
-     * Results are cached for subsequent lookups.
-     *
-     * @param symbol - Token symbol (e.g., 'GALA', 'GWETH', 'GUSDC')
-     * @returns Token metadata including descriptor and decimals
-     * @throws Error if token metadata cannot be found
-     *
-     * @example
-     * ```typescript
-     * const metadata = await resolver.getTokenMetadata('GALA');
-     * // Returns: { descriptor: { collection: 'GALA', ... }, decimals: 8, channel: 'asset' }
-     * ```
-     */
-    getTokenMetadata(symbol: string): Promise<BridgeTokenMetadata>;
-    /**
-     * Check if metadata is available for a symbol (without API call).
-     *
-     * Only checks cache and static metadata.
-     *
-     * @param symbol - Token symbol to check
-     * @returns True if metadata is already available
-     */
-    hasMetadata(symbol: string): boolean;
-    /**
-     * Clear the metadata cache.
-     *
-     * Useful for testing or refreshing stale data.
-     */
-    clearCache(): void;
-    /**
-     * Fetch token metadata from GalaConnect API.
-     *
-     * Matches the exact symbol only. A symbol is never rewritten (no "USDC" -> "GUSDC" guessing);
-     * the class key comes from the matched API entry.
-     *
-     * @param symbol - Token symbol to look up
-     * @returns Token metadata
-     * @throws Error if token not found in API
-     */
-    private fetchFromApi;
-}
-/**
- * Create a TokenMetadataResolver instance.
- *
- * Factory function for convenience.
- *
- * @param galaConnectClient - GalaConnect client for API lookups
- * @returns Configured TokenMetadataResolver
- */
-export declare function createTokenMetadataResolver(galaConnectClient: GalaConnectClient): TokenMetadataResolver;
-//# sourceMappingURL=tokenMetadataResolver.d.ts.map

package/dist/bridge/utils/tokenMetadataResolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenMetadataResolver.d.ts","sourceRoot":"","sources":["../../../src/bridge/utils/tokenMetadataResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAG7D;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,yCAAyC;IACzC,iBAAiB,EAAE,iBAAiB,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0C;gBAEpD,MAAM,EAAE,2BAA2B;IAI/C;;;;;;;;;;;;;;;OAeG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAuBpE;;;;;;;OAOG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAKpC;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;;;;;;OASG;YACW,YAAY;CAqB3B;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,iBAAiB,EAAE,iBAAiB,GACnC,qBAAqB,CAEvB"}

package/dist/helpers/wallet.d.ts

@@ -1,151 +0,0 @@
-/**
- * Wallet creation helper functions
- *
- * Provides convenient functions for creating wallets with auto-detection
- * of input formats (private key vs mnemonic phrase).
- */
-import type { GeneratedWallet } from '../utils/wallet';
-/**
- * Creates a wallet with smart input detection
- *
- * Automatically detects whether the input is a private key or mnemonic phrase,
- * and creates the appropriate wallet. If no input is provided, generates a new
- * random wallet.
- *
- * @param input Optional wallet creation input
- *   - No input: Creates a new random wallet
- *   - 64 hex characters (with/without 0x): Treated as private key
- *   - 12 or 24 space-separated words: Treated as mnemonic phrase
- * @returns Generated wallet with all necessary information
- *
- * @example
- * ```typescript
- * import { createWallet } from '@gala-chain/launchpad-sdk';
- *
- * // Generate new random wallet
- * const newWallet = createWallet();
- *
- * // From private key
- * const pkWallet = createWallet('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12');
- *
- * // From mnemonic
- * const mnemonicWallet = createWallet('word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12');
- *
- * // Use with SDK
- * const sdk = new LaunchpadSDK({ wallet: newWallet.wallet });
- * ```
- */
-export declare function createWallet(input?: string): GeneratedWallet;
-/**
- * Validates wallet input format without creating wallet
- *
- * @param input Input to validate
- * @returns Object with validation result and detected format
- *
- * @example
- * ```typescript
- * const result = validateWalletInput('0x1234...');
- * if (result.valid) {
- *   console.log(`Detected format: ${result.format}`);
- * } else {
- *   console.log(`Validation error: ${result.error}`);
- * }
- * ```
- */
-export declare function validateWalletInput(input: string): {
-    valid: boolean;
-    format?: 'private_key' | 'mnemonic' | 'random';
-    error?: string;
-};
-/**
- * Result of public key derivation containing both formats
- */
-export interface PublicKeyResult {
-    /** Uncompressed public key (0x04... format, 132 characters) */
-    publicKey: string;
-    /** Compressed public key (0x02/03... format, 68 characters) */
-    compressedPublicKey: string;
-}
-/**
- * Derive public key from private key using secp256k1 elliptic curve.
- *
- * Returns both uncompressed and compressed formats of the public key.
- * Uses ethers.js SigningKey for cryptographic operations.
- *
- * @param privateKey - Private key (0x-prefixed 64 hex characters)
- * @returns Public key in both uncompressed and compressed formats
- * @throws Error if private key format is invalid
- *
- * @example
- * ```typescript
- * import { getPublicKeyFromPrivateKey } from '@gala-chain/launchpad-sdk';
- *
- * const result = getPublicKeyFromPrivateKey('0x1234567890abcdef...');
- * console.log(result.publicKey);           // 0x04... (132 chars, uncompressed)
- * console.log(result.compressedPublicKey); // 0x02... or 0x03... (68 chars)
- * ```
- */
-export declare function getPublicKeyFromPrivateKey(privateKey: string): PublicKeyResult;
-/**
- * Derive Ethereum address from private key.
- *
- * Returns the standard Ethereum address in checksum format (0x...).
- * This is the raw Ethereum address, NOT the GalaChain format (eth|...).
- *
- * @param privateKey - Private key (0x-prefixed 64 hex characters)
- * @returns Ethereum address in checksum format (0x...)
- * @throws Error if private key format is invalid
- *
- * @example
- * ```typescript
- * import { getEthereumAddressFromPrivateKey, toBackendAddressFormat } from '@gala-chain/launchpad-sdk';
- *
- * const address = getEthereumAddressFromPrivateKey('0x1234567890abcdef...');
- * console.log(address); // "0x8Ba1f109551bD432803012645Ac136ddd64DBA72"
- *
- * // For GalaChain format, use toBackendAddressFormat:
- * const galaChainAddress = toBackendAddressFormat(address);
- * console.log(galaChainAddress); // "eth|8ba1f109551bd432803012645ac136ddd64dba72"
- * ```
- */
-export declare function getEthereumAddressFromPrivateKey(privateKey: string): string;
-/**
- * Generated Solana wallet information
- */
-export interface GeneratedSolanaWallet {
-    /** Base58-encoded 64-byte secret key (used for signing) */
-    privateKey: string;
-    /** Base58-encoded 32-byte public key */
-    publicKey: string;
-    /** Solana address (same as publicKey - Solana addresses ARE public keys) */
-    address: string;
-}
-/**
- * Creates a new random Solana wallet.
- *
- * Generates a new Ed25519 keypair suitable for use with Solana.
- * The private key is returned in base58 format, compatible with
- * the SDK's bridge operations.
- *
- * @returns Generated Solana wallet with address and keys
- *
- * @example
- * ```typescript
- * import { createSolanaWallet } from '@gala-chain/launchpad-sdk';
- *
- * const wallet = createSolanaWallet();
- * console.log(wallet.address);    // Base58 public key (e.g., "7Vbmv1jt4v...")
- * console.log(wallet.privateKey); // Base58 secret key for signing
- *
- * // Use with bridge operations
- * const sdk = new LaunchpadSDK({ privateKey: ethPrivateKey });
- * await sdk.bridgeIn({
- *   tokenId: 'GALA|Unit|none|none',
- *   amount: '100',
- *   sourceChain: 'Solana',
- *   solanaPrivateKey: wallet.privateKey,
- * });
- * ```
- */
-export declare function createSolanaWallet(): GeneratedSolanaWallet;
-//# sourceMappingURL=wallet.d.ts.map

package/dist/helpers/wallet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/helpers/wallet.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CA6B5D;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG;IAClD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,aAAa,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAwBA;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAe9E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAU3E;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,IAAI,qBAAqB,CAQ1D"}