@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

package/dist/src/utils/websocket-patterns.d.ts

@@ -1,680 +0,0 @@
-/**
- * WebSocket Patterns & Utilities
- *
- * Consolidates recurring WebSocket subscription, event handling, and lifecycle patterns
- * used across multiple streaming services. Eliminates code duplication and provides
- * reusable patterns for real-time features.
- *
- * Patterns consolidated:
- * 1. RoomSubscriptionManager - Room-based subscription tracking with auto-cleanup
- * 2. PayloadWalkerWithDeduplication - Recursive payload traversal with deduplication
- * 3. PendingSubscriptionTracker - Pending subscriptions with timeout guards
- * 4. GlobalAndRoomCallbackDispatcher - Dual-level callback dispatching
- * 5. SelectiveEventForwarding - Event filtering before forwarding
- * 6. ListenerCleanupManager - Multi-stage listener cleanup with error isolation
- * 7. EventBufferWithAutoCleanup - Event buffering with TTL and max size
- * 8. TypingIndicatorDebouncer - Typing indicator debouncing
- *
- * @category Utilities
- * @since 6.6.0
- */
-import type { Logger } from './Logger';
-/**
- * Room Subscription Manager
- *
- * Unified room-based subscription tracking with automatic cleanup and duplicate prevention.
- * Used by StreamWebSocketService, PoolStateManager, and MultiPoolStateManager to track
- * which rooms (token subscriptions, pools, etc.) are currently active.
- *
- * Features:
- * - Duplicate prevention (can't add same room twice)
- * - O(1) subscription checks
- * - Bulk retrieval of subscribed rooms
- * - Automatic cleanup on unsubscribe
- *
- * @example
- * ```typescript
- * // Test case: Room tracking with subscription metadata
- * const manager = new RoomSubscriptionManager();
- *
- * // Add room
- * manager.addRoom('token:anime');
- * console.assert(manager.isSubscribedTo('token:anime') === true);
- *
- * // Prevent duplicates (no-op if already added)
- * manager.addRoom('token:anime'); // Silent duplicate prevention
- *
- * // Get all subscribed rooms
- * const rooms = manager.getRooms();
- * console.assert(rooms.includes('token:anime'));
- *
- * // Remove room
- * manager.removeRoom('token:anime');
- * console.assert(manager.isSubscribedTo('token:anime') === false);
- *
- * // Clear all
- * manager.addRoom('room1');
- * manager.addRoom('room2');
- * manager.clear();
- * console.assert(manager.getRooms().length === 0);
- * ```
- *
- * @since 6.6.0
- */
-export declare class RoomSubscriptionManager {
-    private rooms;
-    /**
-     * Add a room to subscriptions
-     *
-     * No-op if room already exists (duplicate prevention).
-     *
-     * @param roomId - Room identifier (e.g., 'token:anime', 'pool:GALA-USDC')
-     */
-    addRoom(roomId: string): void;
-    /**
-     * Remove a room from subscriptions
-     *
-     * No-op if room doesn't exist.
-     *
-     * @param roomId - Room identifier to remove
-     */
-    removeRoom(roomId: string): void;
-    /**
-     * Get all subscribed rooms
-     *
-     * @returns Array of room identifiers currently subscribed to
-     */
-    getRooms(): string[];
-    /**
-     * Check if subscribed to a room
-     *
-     * @param roomId - Room identifier to check
-     * @returns True if currently subscribed to this room
-     */
-    isSubscribedTo(roomId: string): boolean;
-    /**
-     * Clear all room subscriptions
-     *
-     * Typically called during disconnect or cleanup.
-     */
-    clear(): void;
-    /**
-     * Get count of subscribed rooms
-     *
-     * @returns Number of currently subscribed rooms
-     */
-    get size(): number;
-}
-/**
- * Payload Walker with Deduplication
- *
- * Recursively walks through object payloads to extract events while deduplicating
- * by a key (e.g., transactionId, eventId). Prevents duplicate processing of the
- * same event across multiple payload traversals.
- *
- * Used in LiquidityEventExtractor, SwapEventExtractor, and MultiPoolStateManager
- * to find events nested at various depths in WebSocket payloads.
- *
- * Features:
- * - Recursive depth limiting (prevents DoS from circular structures)
- * - WeakSet tracking to prevent infinite loops on circular references
- * - Configurable deduplication key
- * - Callback-based event processing
- *
- * @example
- * ```typescript
- * // Test case: Recursive payload walking with deduplication
- * const walker = new PayloadWalkerWithDeduplication<{ id: string; value: number }>(
- *   (obj) => {
- *     // Extraction predicate: return event if found
- *     return obj.id && obj.value ? { id: obj.id, value: obj.value } : null;
- *   },
- *   (event) => event.id // Deduplication key
- * );
- *
- * // First walk - extracts new events
- * const events1 = walker.walk({
- *   Data: { id: 'e1', value: 100 },
- *   nested: { id: 'e2', value: 200 }
- * });
- * console.assert(events1.length === 2);
- *
- * // Second walk - skips already seen events
- * const events2 = walker.walk({
- *   Data: { id: 'e1', value: 999 }, // Already seen, skipped
- *   other: { id: 'e3', value: 300 }  // New, included
- * });
- * console.assert(events2.length === 1);
- * console.assert(events2[0].id === 'e3');
- *
- * // Reset deduplication to reprocess all events
- * walker.reset();
- * const events3 = walker.walk({ Data: { id: 'e1', value: 100 } });
- * console.assert(events3.length === 1); // e1 is processed again
- * ```
- *
- * @typeParam T - Event type being extracted
- * @since 6.6.0
- */
-export declare class PayloadWalkerWithDeduplication<T> {
-    private seen;
-    private readonly maxDepth;
-    private readonly extractor;
-    private readonly dedupeKeyFn;
-    constructor(extractor: (obj: unknown) => T | null, dedupeKeyFn: (event: T) => string, maxDepth?: number);
-    /**
-     * Walk through a payload and extract events
-     *
-     * @param payload - Root object to traverse
-     * @returns Array of extracted events not previously seen
-     */
-    walk(payload: unknown): T[];
-    /**
-     * Reset deduplication state to reprocess all events
-     */
-    reset(): void;
-    /**
-     * Get count of deduplicated events
-     *
-     * @returns Number of unique events seen so far
-     */
-    getSeenCount(): number;
-}
-/**
- * Pending Subscription Tracker
- *
- * Tracks pending subscriptions with timeout guards. Prevents memory leaks from
- * subscriptions that never complete. Used when subscribing to streams where
- * confirmation is required from the server.
- *
- * Features:
- * - Automatic timeout handling
- * - Memory leak prevention (clears expired pending)
- * - Tracks pending duration
- * - Fast O(1) checks
- *
- * @example
- * ```typescript
- * // Test case: Pending subscription tracking with timeouts
- * const tracker = new PendingSubscriptionTracker();
- *
- * // Add pending subscription with 1 second timeout
- * tracker.addPending('sub-123', 1000);
- * console.assert(tracker.isPending('sub-123') === true);
- * console.assert(tracker.getPendingCount() === 1);
- *
- * // Mark as completed (timeout won't fire)
- * tracker.removePending('sub-123');
- * console.assert(tracker.isPending('sub-123') === false);
- *
- * // Check if subscription timed out
- * tracker.addPending('sub-456', 100);
- * await new Promise(r => setTimeout(r, 200)); // Wait for timeout
- * tracker.clearExpired(); // Manual cleanup
- * console.assert(tracker.isPending('sub-456') === false);
- *
- * // Multiple pending subscriptions
- * tracker.addPending('sub-a', 1000);
- * tracker.addPending('sub-b', 1000);
- * tracker.addPending('sub-c', 1000);
- * console.assert(tracker.getPendingCount() === 3);
- * ```
- *
- * @since 6.6.0
- */
-export declare class PendingSubscriptionTracker {
-    private pending;
-    /**
-     * Add a pending subscription with timeout
-     *
-     * @param id - Subscription identifier (e.g., token name)
-     * @param timeoutMs - Timeout duration in milliseconds
-     */
-    addPending(id: string, timeoutMs: number): void;
-    /**
-     * Remove a pending subscription (e.g., when it completes or is cancelled)
-     *
-     * @param id - Subscription identifier to remove
-     */
-    removePending(id: string): void;
-    /**
-     * Check if a subscription is pending
-     *
-     * @param id - Subscription identifier to check
-     * @returns True if subscription is still pending
-     */
-    isPending(id: string): boolean;
-    /**
-     * Get count of pending subscriptions
-     *
-     * @returns Number of subscriptions currently pending
-     */
-    getPendingCount(): number;
-    /**
-     * Manually clear expired pending subscriptions
-     *
-     * Normally called automatically by the timeout, but can be called
-     * explicitly for cleanup.
-     */
-    clearExpired(): void;
-    /**
-     * Clear all pending subscriptions
-     */
-    clear(): void;
-}
-/**
- * Global and Room Callback Dispatcher
- *
- * Dispatches callbacks to both global and room-specific listeners in the correct order.
- * Global callbacks execute first, then room-specific callbacks.
- *
- * Used in StreamWebSocketService to ensure consistent callback ordering across
- * different event types.
- *
- * Features:
- * - Global-first execution order
- * - Isolated error handling per listener
- * - Type-safe callback dispatch
- * - Logging for debugging
- *
- * @example
- * ```typescript
- * // Test case: Global and room-specific callbacks
- * interface MyEvent { tokenName: string; value: number }
- * type MyCallback = (event: MyEvent) => void;
- *
- * const dispatcher = new GlobalAndRoomCallbackDispatcher<MyEvent, MyCallback>();
- *
- * const calls: string[] = [];
- *
- * // Register global callback
- * dispatcher.registerGlobalCallback((event) => {
- *   calls.push(`global:${event.tokenName}`);
- * });
- *
- * // Register room-specific callbacks
- * dispatcher.registerRoomCallback('token:anime', (event) => {
- *   calls.push(`room:anime:${event.value}`);
- * });
- * dispatcher.registerRoomCallback('token:gala', (event) => {
- *   calls.push(`room:gala:${event.value}`);
- * });
- *
- * // Dispatch event
- * const event: MyEvent = { tokenName: 'anime', value: 42 };
- * dispatcher.dispatch('token:anime', event);
- *
- * // Global callback should execute first
- * console.assert(calls[0] === 'global:anime');
- * console.assert(calls[1] === 'room:anime:42');
- *
- * // Unrelated room callback not called
- * console.assert(!calls.some(c => c.startsWith('room:gala')));
- * ```
- *
- * @typeParam TEvent - Event type being dispatched
- * @typeParam TCallback - Callback function type
- * @since 6.6.0
- */
-export declare class GlobalAndRoomCallbackDispatcher<TEvent, TCallback extends (event: TEvent) => void> {
-    private globalCallbacks;
-    private roomCallbacks;
-    private logger;
-    constructor(logger?: Logger);
-    /**
-     * Register a global callback
-     *
-     * @param callback - Function to call for all events
-     */
-    registerGlobalCallback(callback: TCallback): void;
-    /**
-     * Register a room-specific callback
-     *
-     * @param roomId - Room identifier (e.g., 'token:anime')
-     * @param callback - Function to call for events in this room
-     */
-    registerRoomCallback(roomId: string, callback: TCallback): void;
-    /**
-     * Dispatch an event to global and room-specific callbacks
-     *
-     * Calls global callbacks first, then room-specific callbacks.
-     * Errors in one callback don't prevent others from executing.
-     *
-     * @param roomId - Room identifier for this event
-     * @param event - Event data to dispatch
-     */
-    dispatch(roomId: string, event: TEvent): void;
-    /**
-     * Clear all callbacks
-     */
-    clear(): void;
-    /**
-     * Remove all callbacks for a specific room
-     *
-     * @param roomId - Room identifier
-     */
-    clearRoom(roomId: string): void;
-}
-/**
- * Selective Event Forwarding
- *
- * Filters events based on multiple predicates before forwarding. Reduces message
- * volume by eliminating noisy or unwanted events.
- *
- * Features:
- * - Multiple filter predicates (AND logic)
- * - Short-circuit evaluation (stops at first failing filter)
- * - Chainable filter registration
- *
- * @example
- * ```typescript
- * // Test case: Event filtering pipeline
- * interface SwapEvent { token0: string; token1: string; amount: string; user: string }
- *
- * const forwarder = new SelectiveEventForwarding<SwapEvent>();
- *
- * // Add filters
- * forwarder.addFilter((event) => event.amount !== '0'); // Skip zero amounts
- * forwarder.addFilter((event) => event.token0 === 'GALA'); // Only GALA swaps
- * forwarder.addFilter((event) => !event.user.includes('bot')); // Skip bot swaps
- *
- * // Test filtering
- * const allowed = { token0: 'GALA', token1: 'USDC', amount: '100', user: 'alice' };
- * console.assert(forwarder.forward(allowed) === true);
- *
- * const zeroAmount = { token0: 'GALA', token1: 'USDC', amount: '0', user: 'alice' };
- * console.assert(forwarder.forward(zeroAmount) === false);
- *
- * const nonGala = { token0: 'USDC', token1: 'USDT', amount: '100', user: 'alice' };
- * console.assert(forwarder.forward(nonGala) === false);
- *
- * const botSwap = { token0: 'GALA', token1: 'USDC', amount: '100', user: 'bot123' };
- * console.assert(forwarder.forward(botSwap) === false);
- * ```
- *
- * @typeParam TEvent - Event type being filtered
- * @since 6.6.0
- */
-export declare class SelectiveEventForwarding<TEvent> {
-    private filters;
-    /**
-     * Add a filter predicate
-     *
-     * Event must pass ALL filters to be forwarded. Filters are evaluated
-     * in the order they were added (short-circuit evaluation).
-     *
-     * @param predicate - Function returning true to allow event, false to block
-     * @returns This instance for chaining
-     */
-    addFilter(predicate: (event: TEvent) => boolean): this;
-    /**
-     * Forward an event if it passes all filters
-     *
-     * @param event - Event to evaluate
-     * @returns True if event passed all filters, false otherwise
-     */
-    forward(event: TEvent): boolean;
-    /**
-     * Clear all filters
-     */
-    clearFilters(): void;
-    /**
-     * Get count of active filters
-     *
-     * @returns Number of filter predicates
-     */
-    get filterCount(): number;
-}
-/**
- * Listener Cleanup Manager
- *
- * Multi-stage cleanup with error isolation per listener. Ensures cleanup
- * of one listener doesn't block cleanup of others.
- *
- * Features:
- * - Error isolation (one failure doesn't block others)
- * - Async cleanup support (waitPromises)
- * - Ordering (LIFO - last registered, first cleaned up)
- * - Detailed error logging
- *
- * @example
- * ```typescript
- * // Test case: Multi-stage listener cleanup
- * const manager = new ListenerCleanupManager();
- * const cleaned: string[] = [];
- *
- * // Register listeners with cleanup functions
- * manager.register('listener1', () => {
- *   cleaned.push('1');
- * });
- * manager.register('listener2', () => {
- *   cleaned.push('2');
- * });
- * manager.register('listener3', () => {
- *   throw new Error('Cleanup failed for 3');
- * });
- * manager.register('listener4', () => {
- *   cleaned.push('4');
- * });
- *
- * // Cleanup all (error in listener3 doesn't block listener4)
- * await manager.cleanup();
- *
- * // All listeners cleaned up despite error in listener3
- * console.assert(cleaned.includes('1'));
- * console.assert(cleaned.includes('2'));
- * console.assert(cleaned.includes('4'));
- * // Order is LIFO: 4, 3 (error), 2, 1
- * ```
- *
- * @since 6.6.0
- */
-export declare class ListenerCleanupManager {
-    private listeners;
-    private logger;
-    constructor(logger?: Logger);
-    /**
-     * Register a listener with cleanup function
-     *
-     * Cleanup functions are called in LIFO order (last registered, first cleaned up).
-     *
-     * @param id - Unique identifier for this listener
-     * @param cleanup - Sync or async cleanup function
-     */
-    register(id: string, cleanup: () => void | Promise<void>): void;
-    /**
-     * Cleanup all listeners
-     *
-     * Errors in one listener don't prevent cleanup of others.
-     * Returns array of errors encountered during cleanup.
-     *
-     * @returns Promise that resolves when all cleanup complete
-     */
-    cleanup(): Promise<Error[]>;
-    /**
-     * Clear all registered listeners without calling cleanup
-     */
-    clear(): void;
-    /**
-     * Get count of registered listeners
-     *
-     * @returns Number of listeners awaiting cleanup
-     */
-    get size(): number;
-}
-/**
- * Event Buffer with Auto-Cleanup
- *
- * Buffers events with TTL (time-to-live) and max size limits. Old events are
- * automatically expired and removed.
- *
- * Features:
- * - Configurable TTL per event
- * - Max size enforcement (FIFO eviction when full)
- * - Automatic expiration cleanup
- * - Memory-efficient
- *
- * @example
- * ```typescript
- * // Test case: Event buffering with TTL and size limits
- * interface LogEvent { id: string; message: string }
- *
- * const buffer = new EventBufferWithAutoCleanup<LogEvent>({
- *   maxSize: 5,
- *   defaultTtlMs: 2000
- * });
- *
- * // Add events
- * buffer.push({ id: 'e1', message: 'Event 1' });
- * buffer.push({ id: 'e2', message: 'Event 2' });
- * console.assert(buffer.getAll().length === 2);
- *
- * // Wait for TTL expiration
- * await new Promise(r => setTimeout(r, 2100));
- * // Manual cleanup (normally automatic)
- * buffer.clear(); // Or events auto-expire
- *
- * // Max size enforcement
- * const buffer2 = new EventBufferWithAutoCleanup<LogEvent>({
- *   maxSize: 3,
- *   defaultTtlMs: 10000
- * });
- * buffer2.push({ id: 'a', message: 'A' });
- * buffer2.push({ id: 'b', message: 'B' });
- * buffer2.push({ id: 'c', message: 'C' });
- * buffer2.push({ id: 'd', message: 'D' }); // Oldest (a) is evicted
- * console.assert(buffer2.getAll().length === 3);
- * console.assert(!buffer2.getAll().some(e => e.id === 'a'));
- * ```
- *
- * @typeParam TEvent - Event type being buffered
- * @since 6.6.0
- */
-export interface EventBufferConfig {
-    maxSize?: number;
-    defaultTtlMs?: number;
-}
-export declare class EventBufferWithAutoCleanup<TEvent> {
-    private events;
-    private timeouts;
-    private readonly maxSize;
-    private readonly defaultTtlMs;
-    private readonly logger;
-    constructor(config?: EventBufferConfig, logger?: Logger);
-    /**
-     * Add an event to the buffer
-     *
-     * If buffer is full, removes oldest event (FIFO).
-     * Event will auto-expire after TTL.
-     *
-     * @param event - Event to buffer
-     */
-    push(event: TEvent): void;
-    /**
-     * Get all currently buffered events
-     *
-     * @returns Array of buffered events
-     */
-    getAll(): TEvent[];
-    /**
-     * Clear all buffered events
-     */
-    clear(): void;
-    /**
-     * Get count of buffered events
-     *
-     * @returns Number of events currently buffered
-     */
-    get size(): number;
-}
-/**
- * Typing Indicator Debouncer
- *
- * Debounces typing indicator events to reduce message volume. Multiple
- * typing events from the same user within the debounce window are collapsed
- * into a single indicator.
- *
- * Features:
- * - Per-user debouncing (independent timers for each user)
- * - Automatic cleanup of pending indicators
- * - Configurable debounce delay
- * - Prevents spam of typing events
- *
- * @example
- * ```typescript
- * // Test case: Typing indicator debouncing
- * const debouncer = new TypingIndicatorDebouncer({
- *   delayMs: 100,
- *   onTyping: (userId, roomId) => {
- *     console.log(`User ${userId} is typing in ${roomId}`);
- *   },
- *   onStopTyping: (userId, roomId) => {
- *     console.log(`User ${userId} stopped typing in ${roomId}`);
- *   }
- * });
- *
- * const events: string[] = [];
- * debouncer.onTyping = (userId, roomId) => {
- *   events.push(`typing:${userId}:${roomId}`);
- * };
- * debouncer.onStopTyping = (userId, roomId) => {
- *   events.push(`stop:${userId}:${roomId}`);
- * };
- *
- * // Rapid typing events from same user
- * debouncer.indicate('user123', 'room1');
- * debouncer.indicate('user123', 'room1');
- * debouncer.indicate('user123', 'room1');
- *
- * // Only one typing event sent (debounced)
- * console.assert(events.filter(e => e.startsWith('typing')).length === 1);
- *
- * // Different users send independent indicators
- * debouncer.indicate('user456', 'room1');
- * debouncer.indicate('user789', 'room1');
- * console.assert(events.filter(e => e.startsWith('typing')).length === 3);
- * ```
- *
- * @since 6.6.0
- */
-export interface TypingIndicatorConfig {
-    delayMs?: number;
-    onTyping?: (userId: string, roomId: string) => void | Promise<void>;
-    onStopTyping?: (userId: string, roomId: string) => void | Promise<void>;
-}
-export declare class TypingIndicatorDebouncer {
-    private pendingIndicators;
-    private activeIndicators;
-    private readonly delayMs;
-    private readonly onTyping;
-    private readonly onStopTyping;
-    constructor(config?: TypingIndicatorConfig, _logger?: Logger);
-    /**
-     * Indicate that a user is typing
-     *
-     * If user is already typing, the debounce window is reset.
-     * Stop indicator is sent after delayMs of inactivity.
-     *
-     * @param userId - User identifier
-     * @param roomId - Room identifier (e.g., 'token:anime')
-     */
-    indicate(userId: string, roomId: string): void;
-    /**
-     * Explicitly stop typing indicator for a user
-     *
-     * @param userId - User identifier
-     * @param roomId - Room identifier
-     */
-    stopTyping(userId: string, roomId: string): void;
-    /**
-     * Clear all pending typing indicators
-     */
-    clear(): void;
-    /**
-     * Get count of active typing indicators
-     *
-     * @returns Number of users currently typing
-     */
-    get activeCount(): number;
-}
-//# sourceMappingURL=websocket-patterns.d.ts.map

package/dist/src/utils/websocket-patterns.d.ts.map

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