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

package/dist/examples/utils/sdk-setup.d.ts

@@ -0,0 +1,423 @@
+/**
+ * Shared SDK Setup Utility for Examples
+ *
+ * Consolidates the common SDK initialization pattern used across all demo scripts.
+ * Handles environment detection, private key validation, and SDK creation.
+ *
+ * @example Read-only operations (no wallet required)
+ * ```typescript
+ * import { setupReadOnlySDK } from '../utils/sdk-setup';
+ *
+ * const sdk = await setupReadOnlySDK();
+ * const pools = await sdk.fetchPools();
+ * ```
+ *
+ * @example Authenticated operations (wallet required)
+ * ```typescript
+ * import { setupAuthenticatedSDK } from '../utils/sdk-setup';
+ *
+ * const { sdk, walletAddress } = await setupAuthenticatedSDK();
+ * await sdk.buy({ tokenName: 'anime', ... });
+ * ```
+ *
+ * @example Orchestrated demos (SDK provided externally)
+ * ```typescript
+ * import { setupSDK } from '../utils/sdk-setup';
+ *
+ * export async function runDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, walletAddress } = await setupSDK({ providedSdk });
+ *   // ... demo logic
+ * }
+ * ```
+ *
+ * @since 5.0.2
+ */
+import './suppress-logging';
+import './load-env';
+import type { LaunchpadSDK } from '../../src';
+/** Options for SDK setup */
+export interface SetupSDKOptions {
+    /** Optional SDK instance from orchestrator (skips creation if provided) */
+    providedSdk?: LaunchpadSDK;
+    /** Enable debug logging in SDK (default: false) */
+    debug?: boolean;
+    /** Custom private key (defaults to WALLET_PRIVATE_KEY env var) */
+    privateKey?: string;
+    /**
+     * Include streaming configuration from environment variables.
+     * When true, reads STREAM_WEBSOCKET_URL and STREAM_ADMIN_API_KEY.
+     */
+    streaming?: boolean;
+}
+/** Result from SDK setup */
+export interface SetupSDKResult {
+    /** Configured SDK instance */
+    sdk: LaunchpadSDK;
+    /** Wallet address (empty string for read-only SDK) */
+    walletAddress: string;
+    /** Current environment (PROD or STAGE) */
+    environment: 'PROD' | 'STAGE';
+}
+/**
+ * Setup SDK with flexible options for demos
+ *
+ * Handles three scenarios:
+ * 1. Provided SDK (from orchestrator) - uses it directly
+ * 2. With private key - creates authenticated SDK
+ * 3. Without private key - creates read-only SDK
+ *
+ * @param options - Setup options
+ * @returns SDK instance and wallet information
+ */
+export declare function setupSDK(options?: SetupSDKOptions): Promise<SetupSDKResult>;
+/**
+ * Setup read-only SDK (no wallet required)
+ *
+ * Convenience wrapper for demos that only read data.
+ *
+ * @param debug - Enable debug logging (default: false)
+ * @returns SDK instance and environment info
+ */
+export declare function setupReadOnlySDK(debug?: boolean): Promise<SetupSDKResult>;
+/**
+ * Setup authenticated SDK (wallet required)
+ *
+ * Throws if WALLET_PRIVATE_KEY is not set.
+ *
+ * @param options - Optional setup options
+ * @returns SDK instance with wallet information
+ * @throws Error if no private key is available
+ */
+export declare function setupAuthenticatedSDK(options?: Omit<SetupSDKOptions, 'providedSdk'>): Promise<SetupSDKResult>;
+/**
+ * Setup SDK for streaming/chat demos (wallet required + streaming config)
+ *
+ * Convenience wrapper that enables streaming configuration automatically.
+ * Uses PRIVATE_KEY env var (streaming demos use this instead of WALLET_PRIVATE_KEY).
+ *
+ * @param options - Optional setup options
+ * @returns SDK instance with wallet information and streaming config
+ * @throws ConfigurationError if no private key is available
+ */
+export declare function setupStreamingSDK(options?: Omit<SetupSDKOptions, 'providedSdk' | 'streaming'>): Promise<SetupSDKResult>;
+/**
+ * Get private key from environment with validation
+ *
+ * @returns Private key string
+ * @throws Error if not set
+ */
+export declare function requirePrivateKey(): string;
+/**
+ * Extended options for orchestrator-compatible demo setup
+ */
+export interface DemoSetupOptions extends SetupSDKOptions {
+    /** Skip logging environment/wallet info (default: false) */
+    silent?: boolean;
+}
+/**
+ * Extended result from demo setup with cleanup helper
+ */
+export interface DemoSetupResult extends SetupSDKResult {
+    /**
+     * Whether this demo should handle its own cleanup.
+     * True when running standalone, false when orchestrated.
+     */
+    shouldCleanup: boolean;
+    /**
+     * Log environment and wallet info if running standalone.
+     * Call this at the start of your demo after setup.
+     */
+    logContext: () => void;
+    /**
+     * Cleanup SDK and optionally exit process.
+     * Only performs cleanup if shouldCleanup is true.
+     * @param exitCode - Optional exit code (default: 0). Pass `false` to skip process.exit.
+     */
+    cleanup: (exitCode?: number | false) => Promise<void>;
+}
+/**
+ * Setup SDK for orchestrator-compatible demos with automatic cleanup handling.
+ *
+ * This is the recommended way to set up demos that can run both standalone
+ * and as part of an orchestrator. It eliminates the common boilerplate:
+ * - `const shouldCleanup = !providedSdk`
+ * - `if (!providedSdk) { log.info(...) }`
+ * - `if (shouldCleanup != null) { await sdk.cleanup(); process.exit(0); }`
+ *
+ * @param options - Setup options including providedSdk from orchestrator
+ * @returns Extended setup result with cleanup helpers
+ *
+ * @example Basic orchestrator-compatible demo
+ * ```typescript
+ * import { setupDemoSDK, log } from '../utils';
+ *
+ * export async function runMyDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, logContext, cleanup } = await setupDemoSDK({ providedSdk });
+ *   logContext(); // Logs environment/wallet only when standalone
+ *
+ *   try {
+ *     // ... demo logic
+ *     log.success('Demo complete!');
+ *   } finally {
+ *     await cleanup(); // Only cleans up when standalone
+ *   }
+ * }
+ * ```
+ *
+ * @example With try/catch pattern
+ * ```typescript
+ * export async function runMyDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, logContext, cleanup } = await setupDemoSDK({ providedSdk });
+ *   logContext();
+ *
+ *   try {
+ *     await sdk.fetchPools();
+ *   } catch (error) {
+ *     log.error(`Demo failed: ${formatErrorMessage(error)}`);
+ *     throw error; // Re-throw for orchestrator
+ *   } finally {
+ *     await cleanup();
+ *   }
+ * }
+ * ```
+ *
+ * @since 5.14.0
+ */
+export declare function setupDemoSDK(options?: DemoSetupOptions): Promise<DemoSetupResult>;
+/**
+ * Setup authenticated SDK for orchestrator-compatible demos.
+ *
+ * Same as setupDemoSDK but requires a wallet/private key.
+ *
+ * @param options - Setup options including providedSdk from orchestrator
+ * @returns Extended setup result with cleanup helpers
+ * @throws Error if no private key available when running standalone
+ *
+ * @example
+ * ```typescript
+ * export async function runTradingDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, logContext, cleanup } = await setupAuthenticatedDemoSDK({ providedSdk });
+ *   logContext();
+ *
+ *   try {
+ *     await sdk.buy({ ... });
+ *   } finally {
+ *     await cleanup();
+ *   }
+ * }
+ * ```
+ *
+ * @since 5.14.0
+ */
+export declare function setupAuthenticatedDemoSDK(options?: DemoSetupOptions): Promise<DemoSetupResult>;
+/**
+ * Setup read-only SDK for orchestrator-compatible demos.
+ *
+ * Same as setupDemoSDK but explicitly for read-only operations.
+ * Does not require a wallet.
+ *
+ * @param options - Setup options including providedSdk from orchestrator
+ * @returns Extended setup result with cleanup helpers
+ *
+ * @example
+ * ```typescript
+ * export async function runPoolDiscoveryDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, logContext, cleanup } = await setupReadOnlyDemoSDK({ providedSdk });
+ *   logContext();
+ *
+ *   try {
+ *     const pools = await sdk.fetchPools({pageSize: 10});
+ *     log.result('Pools found', pools.pools.length);
+ *   } finally {
+ *     await cleanup();
+ *   }
+ * }
+ * ```
+ *
+ * @since 5.14.0
+ */
+export declare function setupReadOnlyDemoSDK(options?: DemoSetupOptions): Promise<DemoSetupResult>;
+/**
+ * Type for demo function implementations.
+ * The demo function receives an SDK instance and performs its operations.
+ *
+ * @example
+ * ```typescript
+ * export const runDemo = wrapAuthenticatedDemo(async (sdk) => {
+ *   const result = await sdk.buyTokens('TEST', '100');
+ *   log.success('Buy complete!');
+ * });
+ * ```
+ */
+export type DemoFunction = (sdk: LaunchpadSDK) => Promise<void>;
+/**
+ * Type for the wrapped demo function that's orchestrator-compatible.
+ */
+export type WrappedDemoFunction = (providedSdk?: LaunchpadSDK) => Promise<void>;
+/**
+ * Options for the demo wrapper HOF.
+ */
+export interface WrapDemoOptions {
+    /**
+     * Whether the demo requires authentication (wallet).
+     * When true, uses setupAuthenticatedDemoSDK.
+     * When false, uses setupDemoSDK (read-only).
+     * @default true
+     */
+    authenticated?: boolean;
+    /**
+     * Enable debug logging in SDK.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Section title to display at the start of the demo.
+     * If not provided, no section header is logged.
+     */
+    sectionTitle?: string;
+}
+/**
+ * Higher-Order Function that wraps a demo function with standard setup/cleanup/context logging.
+ *
+ * This eliminates the repetitive boilerplate pattern:
+ * ```typescript
+ * export async function runXDemo(providedSdk?: LaunchpadSDK): Promise<void> {
+ *   const { sdk, logContext, cleanup } = await setupAuthenticatedDemoSDK({ providedSdk });
+ *   logContext();
+ *
+ *   try {
+ *     // demo logic
+ *   } finally {
+ *     await cleanup();
+ *   }
+ * }
+ * ```
+ *
+ * And replaces it with:
+ * ```typescript
+ * export const runXDemo = wrapDemoFunction(async (sdk) => {
+ *   // demo logic
+ * });
+ * ```
+ *
+ * @param demoFn - The demo function implementation that receives the SDK
+ * @param options - Optional configuration for the wrapper
+ * @returns An orchestrator-compatible demo function
+ *
+ * @example Basic authenticated demo
+ * ```typescript
+ * import { wrapDemoFunction, log } from '../utils';
+ *
+ * export const runMyDemo = wrapDemoFunction(async (sdk) => {
+ *   log.section('My Demo');
+ *   const balance = await sdk.fetchGalaBalance();
+ *   log.result('Balance', balance.quantity);
+ * });
+ *
+ * // Standalone execution
+ * if (require.main === module) {
+ *   runMyDemo().catch((error) => { ... });
+ * }
+ * ```
+ *
+ * @example Read-only demo
+ * ```typescript
+ * export const runPoolDemo = wrapDemoFunction(
+ *   async (sdk) => {
+ *     const pools = await sdk.fetchPools({pageSize: 10});
+ *     log.result('Pools', pools.pools.length);
+ *   },
+ *   { authenticated: false }
+ * );
+ * ```
+ *
+ * @example With section title
+ * ```typescript
+ * export const runTradingDemo = wrapDemoFunction(
+ *   async (sdk) => {
+ *     // Demo logic - section header already logged
+ *     await sdk.buy({ ... });
+ *   },
+ *   { sectionTitle: 'Trading Demo' }
+ * );
+ * ```
+ *
+ * @since 5.16.0
+ */
+export declare function wrapDemoFunction(demoFn: DemoFunction, options?: WrapDemoOptions): WrappedDemoFunction;
+/**
+ * Convenience wrapper for authenticated demos.
+ * Same as wrapDemoFunction with authenticated: true (the default).
+ *
+ * @param demoFn - The demo function implementation
+ * @param options - Optional configuration (authenticated is ignored, always true)
+ * @returns An orchestrator-compatible demo function
+ *
+ * @example
+ * ```typescript
+ * export const runTradingDemo = wrapAuthenticatedDemo(async (sdk) => {
+ *   await sdk.buy({ tokenName: 'anime', ... });
+ * });
+ * ```
+ *
+ * @since 5.16.0
+ */
+export declare function wrapAuthenticatedDemo(demoFn: DemoFunction, options?: Omit<WrapDemoOptions, 'authenticated'>): WrappedDemoFunction;
+/**
+ * Convenience wrapper for read-only demos.
+ * Same as wrapDemoFunction with authenticated: false.
+ *
+ * @param demoFn - The demo function implementation
+ * @param options - Optional configuration (authenticated is ignored, always false)
+ * @returns An orchestrator-compatible demo function
+ *
+ * @example
+ * ```typescript
+ * export const runPoolDiscoveryDemo = wrapReadOnlyDemo(async (sdk) => {
+ *   const pools = await sdk.fetchPools({pageSize: 10});
+ *   log.result('Pools found', pools.pools.length);
+ * });
+ * ```
+ *
+ * @since 5.16.0
+ */
+export declare function wrapReadOnlyDemo(demoFn: DemoFunction, options?: Omit<WrapDemoOptions, 'authenticated'>): WrappedDemoFunction;
+/**
+ * Run a demo function if the script is executed directly (standalone mode).
+ *
+ * This is a DRY helper that eliminates the common boilerplate pattern:
+ * ```typescript
+ * if (require.main === module) {
+ *   runDemo().catch((error) => {
+ *     console.error('Demo failed:', error);
+ *     process.exit(1);
+ *   });
+ * }
+ * ```
+ *
+ * @param demoFn - The async demo function to execute
+ * @param currentModule - Pass `module` from the calling file
+ * @param errorFormatter - Optional error formatter (default: extracts message from Error)
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { runIfMain } from '../utils';
+ *
+ * async function runMyDemo() {
+ *   // Demo logic...
+ * }
+ *
+ * runIfMain(runMyDemo);
+ * ```
+ *
+ * @example With custom error formatting
+ * ```typescript
+ * import { runIfMain, formatErrorMessage } from '../utils';
+ *
+ * runIfMain(runMyDemo, formatErrorMessage);
+ * ```
+ *
+ * @since 5.15.0
+ */
+export declare function runIfMain(demoFn: () => Promise<void>, currentModule?: NodeModule, errorFormatter?: (error: unknown) => string): void;
+//# sourceMappingURL=sdk-setup.d.ts.map

package/dist/examples/utils/sdk-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-setup.d.ts","sourceRoot":"","sources":["../../../examples/utils/sdk-setup.ts"],"names":[],"mappings":"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"}

package/dist/examples/utils/suppress-logging.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Suppress verbose fabric-contract-api decorator logging
+ *
+ * IMPORTANT: Import this FIRST in any script before importing the SDK!
+ *
+ * Example:
+ *   import '../utils/suppress-logging';  // Must be first!
+ *   import { createLaunchpadSDK } from '../../src/index';
+ */
+declare const originalConsoleError: (...data: any[]) => void;
+//# sourceMappingURL=suppress-logging.d.ts.map

package/dist/examples/utils/suppress-logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suppress-logging.d.ts","sourceRoot":"","sources":["../../../examples/utils/suppress-logging.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,QAAA,MAAM,oBAAoB,0BAAgB,CAAC"}

package/dist/examples/utils/token-naming.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Token Naming Utilities for Examples
+ *
+ * Provides consistent token name and symbol generation for test tokens
+ * across all demo scripts. Eliminates duplicated random generation logic.
+ *
+ * @example Generate simple test token names
+ * ```typescript
+ * import { generateTestTokenName, generateTestSymbol } from '../utils/token-naming';
+ *
+ * const tokenName = generateTestTokenName(); // "test123456" (10 chars, unique)
+ * const symbol = generateTestSymbol(); // "TTABCD" (6 chars)
+ * ```
+ *
+ * @example With custom prefixes
+ * ```typescript
+ * const name = generateTestTokenName('pool'); // "pool123456"
+ * const symbol = generateTestSymbol('BC'); // "BCXYZ1"
+ * ```
+ *
+ * @since 5.13.0
+ */
+/**
+ * Generate a unique test token name with timestamp and random suffix.
+ *
+ * Format: `<prefix><timestamp_last_4_digits><4_random_chars>`
+ * Example: "test1234abcd" (12 chars total)
+ *
+ * Uses timestamp + random chars to ensure uniqueness even when
+ * multiple demos run concurrently or within the same millisecond.
+ *
+ * @param prefix - Token name prefix (default: 'test', 4 chars recommended)
+ * @returns Unique token name (max 20 chars)
+ *
+ * @example
+ * ```typescript
+ * const name1 = generateTestTokenName(); // "test1234abcd"
+ * const name2 = generateTestTokenName('demo'); // "demo5678wxyz"
+ * const name3 = generateTestTokenName('tk'); // "tk9012qrst" (10 chars)
+ * ```
+ */
+export declare function generateTestTokenName(prefix?: string): string;
+/**
+ * Generate a unique test token symbol with random uppercase letters.
+ *
+ * Format: `<prefix><4_random_uppercase_letters>`
+ * Example: "TTABCD" (6 chars total)
+ *
+ * Uses random character selection from A-Z for variety.
+ * Backend requires uppercase letters only, no numbers.
+ *
+ * @param prefix - Symbol prefix (default: 'TT', typically 2 chars)
+ * @returns Unique token symbol (typically 6 chars)
+ *
+ * @example
+ * ```typescript
+ * const symbol1 = generateTestSymbol(); // "TTABCD"
+ * const symbol2 = generateTestSymbol('BC'); // "BCXYZW"
+ * const symbol3 = generateTestSymbol('X'); // "XWQPKR" (6 chars)
+ * ```
+ */
+export declare function generateTestSymbol(prefix?: string): string;
+/**
+ * Generate both token name and symbol pair for consistent naming.
+ *
+ * Generates a matching token name and symbol with related prefixes.
+ *
+ * @param namePrefix - Token name prefix (default: 'test', 4 chars recommended)
+ * @param symbolPrefix - Symbol prefix (default: 'TT', typically 2 chars)
+ * @returns Object with `tokenName` and `tokenSymbol` properties
+ *
+ * @example
+ * ```typescript
+ * const token = generateTestTokenPair();
+ * // { tokenName: 'test123456', tokenSymbol: 'TTABCD' }
+ *
+ * const custom = generateTestTokenPair('pool', 'PL');
+ * // { tokenName: 'pool654321', tokenSymbol: 'PLWXYZ' }
+ * ```
+ */
+export declare function generateTestTokenPair(namePrefix?: string, symbolPrefix?: string): {
+    tokenName: string;
+    tokenSymbol: string;
+};
+/**
+ * Validate token name format.
+ *
+ * Token names should be lowercase alphanumeric, 6-20 characters.
+ *
+ * @param tokenName - Token name to validate
+ * @returns True if valid token name format
+ *
+ * @example
+ * ```typescript
+ * isValidTokenName('anime'); // true
+ * isValidTokenName('ANIME'); // false (uppercase not allowed)
+ * isValidTokenName('my token'); // false (spaces not allowed)
+ * ```
+ */
+export declare function isValidTokenName(tokenName: string): boolean;
+/**
+ * Validate token symbol format.
+ *
+ * Symbols should be uppercase alphanumeric, 3-10 characters.
+ *
+ * @param tokenSymbol - Token symbol to validate
+ * @returns True if valid token symbol format
+ *
+ * @example
+ * ```typescript
+ * isValidTokenSymbol('GALA'); // true
+ * isValidTokenSymbol('gala'); // false (lowercase not allowed)
+ * isValidTokenSymbol('GA'); // false (too short)
+ * ```
+ */
+export declare function isValidTokenSymbol(tokenSymbol: string): boolean;
+//# sourceMappingURL=token-naming.d.ts.map

package/dist/examples/utils/token-naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-naming.d.ts","sourceRoot":"","sources":["../../../examples/utils/token-naming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,MAAe,GAAG,MAAM,CAMrE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,MAAa,GAAG,MAAM,CAOhE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,GAAE,MAAe,EAC3B,YAAY,GAAE,MAAa,GAC1B;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAK5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAI3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI/D"}