@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

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

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

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

@@ -0,0 +1,69 @@
+/**
+ * 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';
+/**
+ * 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;
+//# sourceMappingURL=strategyDelegation.d.ts.map

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

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

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

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

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

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

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

@@ -0,0 +1,97 @@
+/**
+ * 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.
+     *
+     * Handles both exact symbol matches and G-prefixed variants
+     * (e.g., "USDC" -> "GUSDC").
+     *
+     * @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

@@ -0,0 +1 @@
+{"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;CA+B3B;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,iBAAiB,EAAE,iBAAiB,GACnC,qBAAqB,CAEvB"}

package/dist/config/environments.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Environment configuration for the Launchpad SDK
+ *
+ * Provides pre-configured URL sets for different environments to simplify SDK initialization.
+ */
+/**
+ * Available environment types
+ */
+export type Environment = 'PROD' | 'STAGE' | 'QA1';
+/**
+ * URL configuration for each environment
+ */
+export interface EnvironmentConfig {
+    /** Main Launchpad API URL */
+    launchpadBaseUrl: string;
+    /** GalaChain Gateway URL */
+    galaChainBaseUrl: string;
+    /** Bundle service URL for transactions */
+    bundleBaseUrl: string;
+    /** WebSocket URL for transaction monitoring */
+    webSocketUrl: string;
+    /** DEX API URL for launchpad token balances */
+    dexApiBaseUrl: string;
+    /** DEX Backend URL for price oracle (price history) */
+    dexBackendBaseUrl: string;
+    /** Launchpad Frontend URL for token pages */
+    launchpadFrontendUrl: string;
+}
+/**
+ * Pre-configured URL sets for each environment
+ *
+ * These configurations are automatically applied when using the `env` parameter
+ * in SDK initialization, eliminating the need to manually specify all URLs.
+ */
+export declare const ENVIRONMENT_URLS: Record<Environment, EnvironmentConfig>;
+/**
+ * Gets the URL configuration for a specific environment
+ *
+ * @param env The environment to get configuration for
+ * @returns Complete URL configuration for the environment
+ *
+ * @example
+ * ```typescript
+ * const config = getEnvironmentConfig('PROD');
+ * console.log(config.launchpadBaseUrl); // 'https://lpad-backend-prod1.defi.gala.com'
+ * ```
+ */
+export declare function getEnvironmentConfig(env: Environment): EnvironmentConfig;
+//# sourceMappingURL=environments.d.ts.map

package/dist/config/environments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environments.d.ts","sourceRoot":"","sources":["../../src/config/environments.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,4BAA4B;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,aAAa,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,iBAAiB,CA8BnE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,WAAW,GAAG,iBAAiB,CAExE"}

package/dist/constants/bondingCurve.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Bonding Curve Mathematical Constants
+ *
+ * These constants define the pricing model for launchpad tokens using an exponential bonding curve.
+ * The bonding curve ensures that token prices increase as supply increases, creating natural price discovery.
+ *
+ * @category Constants
+ * @since 3.8.0
+ *
+ * @example Using constants directly
+ * ```typescript
+ * import { BondingCurveConstants } from '@gala-chain/launchpad-sdk';
+ *
+ * console.log('Base Price:', BondingCurveConstants.BASE_PRICE);
+ * console.log('Max Supply:', BondingCurveConstants.LAUNCHPAD_TOKEN_MAX_SUPPLY);
+ * ```
+ */
+export declare class BondingCurveConstants {
+    /**
+     * Base price of the first token in the bonding curve
+     *
+     * This determines the initial cost when supply is at its minimum.
+     * The price increases exponentially as more tokens are minted.
+     *
+     * @constant
+     * @default 0.00001650667151
+     */
+    static readonly BASE_PRICE = 0.00001650667151;
+    /**
+     * Scaling factor controlling the rate of price increase
+     *
+     * Higher values cause faster price appreciation as supply grows.
+     * This factor is applied to supply in exponential calculations.
+     *
+     * @constant
+     * @default 0.000001166069
+     */
+    static readonly PRICE_SCALING_FACTOR = 0.000001166069;
+    /**
+     * Trading fee percentage (0.1%)
+     *
+     * Applied to all buy and sell transactions as a transaction fee.
+     * Calculated as: transactionAmount * TRADING_FEE_FACTOR
+     *
+     * @constant
+     * @default 0.001
+     */
+    static readonly TRADING_FEE_FACTOR = 0.001;
+    /**
+     * Static gas fee in GALA
+     *
+     * Fixed fee charged for blockchain transaction execution.
+     * This covers the cost of processing the transaction on GalaChain.
+     *
+     * @constant
+     * @default "1"
+     */
+    static readonly GAS_FEE = "1";
+    /**
+     * Minimum unbonding fee factor (0%)
+     *
+     * Base fee applied when selling tokens back to the bonding curve.
+     * Combined with supply-based dynamic fee for total unbonding cost.
+     *
+     * @constant
+     * @default 0
+     */
+    static readonly MIN_UNBONDING_FEE_FACTOR = 0;
+    /**
+     * Maximum unbonding fee factor (50%)
+     *
+     * Maximum additional fee that can be applied when selling tokens.
+     * Used in combination with current supply to calculate dynamic fees.
+     *
+     * @constant
+     * @default 0.5
+     */
+    static readonly MAX_UNBONDING_FEE_FACTOR = 0.5;
+    /**
+     * Net unbonding fee factor (50%)
+     *
+     * Used to calculate supply-proportional unbonding fees.
+     * Applied as: (currentSupply / maxSupply) * NET_UNBONDING_FEE_FACTOR
+     *
+     * @constant
+     * @default 0.5
+     */
+    static readonly NET_UNBONDING_FEE_FACTOR = 0.5;
+    /**
+     * Default maximum total supply for launchpad tokens
+     *
+     * This is the default value used when a token's specific maxSupply is not provided.
+     * Each token can have its own maxSupply value returned from pool details.
+     * Once this supply is reached, the token "graduates" from the bonding curve
+     * and becomes available for trading on the full DEX.
+     *
+     * @constant
+     * @default 10000000
+     */
+    static readonly DEFAULT_LAUNCHPAD_TOKEN_MAX_SUPPLY = 10000000;
+}
+//# sourceMappingURL=bondingCurve.d.ts.map

package/dist/constants/bondingCurve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bondingCurve.d.ts","sourceRoot":"","sources":["../../src/constants/bondingCurve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAqB;IAChC;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,UAAU,oBAAoB;IAE9C;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,oBAAoB,kBAAkB;IAEtD;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,kBAAkB,SAAS;IAE3C;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,OAAO;IAE9B;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,KAAK;IAE7C;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,OAAO;IAE/C;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,wBAAwB,OAAO;IAE/C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,CAAC,kCAAkC,YAAY;CAC/D"}

package/dist/constants/config.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SDK Configuration Constants
+ *
+ * Core configuration values for SDK behavior and performance tuning.
+ *
+ * @category Constants
+ * @since 3.11.0
+ */
+/**
+ * Maximum concurrent pool fetch requests for auto-pagination
+ *
+ * When fetching multiple pages of pools (e.g., limit: 100 or limit: 0),
+ * this controls how many API requests can run in parallel.
+ *
+ * **Balances:**
+ * - Higher values = faster data fetching
+ * - Lower values = more API-friendly, less risk of rate limiting
+ *
+ * **Default:** 5 concurrent requests
+ *
+ * @example
+ * ```typescript
+ * import { MAX_CONCURRENT_POOL_FETCHES } from '@gala-chain/launchpad-sdk';
+ *
+ * console.log(`SDK will fetch up to ${MAX_CONCURRENT_POOL_FETCHES} pages concurrently`);
+ * // Output: "SDK will fetch up to 5 pages concurrently"
+ * ```
+ */
+export declare const MAX_CONCURRENT_POOL_FETCHES = 5;
+//# sourceMappingURL=config.d.ts.map

package/dist/constants/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/constants/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC"}