@gala-chain/launchpad-sdk 3.31.2 → 4.0.1-beta.0

package/dist/src/services/PoolCacheManager.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Pool Cache Manager
+ *
+ * Manages tiered LRU caching of pool state with automatic refetching.
+ * Optimized for swap monitoring with delta-based updates instead of full refetches.
+ *
+ * Cache Tiers:
+ * - Hot Cache (50 pools): Never evicted, ~infinite TTL, highest priority
+ * - Warm Cache (200 pools): 30-minute TTL, automatic refresh
+ * - Cold Cache (500 max total): 5-minute TTL, LRU eviction
+ *
+ * @packageDocumentation
+ */
+import type { CompositePoolDataResult } from '../types/composite-pool.dto';
+import type { SwapMonitorConfig, SwapEventData as SwapMonitorEvent } from '../types/swap-monitor.dto';
+import { Logger } from '../utils/Logger';
+import { MonitoringMetrics } from '../utils/MonitoringMetrics';
+/**
+ * Cache tier classification
+ *
+ * @internal
+ */
+type CacheTier = 'hot' | 'warm' | 'cold';
+/**
+ * Manages tiered LRU pool cache for swap monitoring
+ *
+ * Maintains hot/warm/cold cache tiers with automatic eviction and refetching.
+ * Tracks cache performance metrics and applies swap deltas efficiently.
+ *
+ * @internal
+ */
+export declare class PoolCacheManager {
+    private readonly cache;
+    private readonly metrics;
+    private readonly config;
+    private readonly logger;
+    private readonly fetchPoolFn;
+    /** Configuration with defaults applied */
+    private readonly tierSizes;
+    /** TTL in milliseconds per tier */
+    private readonly tierTTLs;
+    /** Refetch thresholds */
+    private readonly refetchThresholds;
+    constructor(fetchPoolFn: (poolKey: string) => Promise<CompositePoolDataResult>, config: Required<SwapMonitorConfig>, metrics: MonitoringMetrics, logger?: Logger);
+    /**
+     * Get pool data from cache, fetching if necessary
+     *
+     * Implements three-tier cache strategy:
+     * 1. Check hot cache (never expires)
+     * 2. Check warm cache (30-min TTL)
+     * 3. Check cold cache (5-min TTL)
+     * 4. Fetch from backend if not found or expired
+     *
+     * @param poolKey - Pool identifier
+     * @returns Pool data
+     */
+    getPool(poolKey: string): Promise<CompositePoolDataResult>;
+    /**
+     * Update pool cache with swap delta
+     *
+     * Applies swap delta to cached pool state using SwapDeltaCalculator.
+     * Tracks swap count, drift accumulation, and marks for refetch when thresholds exceeded.
+     *
+     * Performance: 25-50ms for typical swaps (1-3 tick crossings)
+     *
+     * @param poolKey - Pool identifier
+     * @param direction - Swap direction (zeroForOne or oneForZero)
+     * @param amount0 - Amount of token0
+     * @param amount1 - Amount of token1
+     * @param swapEvent - Full swap event data for delta calculation
+     * @returns Whether delta was successfully applied
+     */
+    updatePoolWithSwapDelta(poolKey: string, direction: 'zeroForOne' | 'oneForZero', amount0: string, amount1: string, swapEvent?: SwapMonitorEvent): boolean;
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache stats with tier breakdown
+     */
+    getStats(): {
+        totalCached: number;
+        hotCacheSize: number;
+        warmCacheSize: number;
+        coldCacheSize: number;
+        memoryUsedMB: number;
+    };
+    /**
+     * Get information about a cached pool
+     *
+     * @param poolKey - Pool identifier
+     * @returns Pool info or null if not cached
+     */
+    getPoolInfo(poolKey: string): {
+        poolKey: string;
+        tier: CacheTier;
+        lastAccessTime: Date;
+        expiresAt: Date;
+        swapsSinceRefetch: number;
+        cumulativeDrift: number;
+        isExpired: boolean;
+    } | null;
+    /**
+     * Warm cache with a pool (eager preload)
+     *
+     * Fetches and caches pool data for future access. Used during startup
+     * to preload high-priority pools.
+     *
+     * @param poolKey - Pool identifier to warm
+     * @returns Whether pool was successfully warmed
+     */
+    warmCache(poolKey: string): Promise<boolean>;
+    /**
+     * Warm cache with multiple pools (batch eager preload)
+     *
+     * Fetches multiple pools in parallel with concurrency control.
+     * Useful for preloading top pools at startup.
+     *
+     * @param poolKeys - Array of pool identifiers to warm
+     * @param maxConcurrent - Maximum parallel requests (default: 5)
+     * @returns Statistics on warming results
+     */
+    warmCacheBatch(poolKeys: string[], maxConcurrent?: number): Promise<{
+        succeeded: number;
+        failed: number;
+        total: number;
+    }>;
+    /**
+     * Clear entire cache
+     */
+    clear(): void;
+    /**
+     * Clear expired entries
+     */
+    clearExpired(): void;
+    /**
+     * Determine which tier a new pool should be added to
+     *
+     * @internal
+     */
+    private determineTier;
+    /**
+     * Check if pool needs refetching
+     *
+     * @internal
+     */
+    private checkRefetchNeeded;
+    /**
+     * Check if refetch thresholds are exceeded
+     *
+     * @internal
+     */
+    private shouldRefetch;
+    /**
+     * Evict least recently used entries from cold cache
+     *
+     * Only evicts from cold cache tier. Preserves hot and warm caches.
+     *
+     * @internal
+     */
+    private evictLRU;
+    /**
+     * Refresh hot and warm tier pools
+     *
+     * Called periodically by background warming to keep frequently accessed
+     * pools fresh and prevent accumulated drift from delta-only updates.
+     *
+     * @internal
+     */
+    refreshWarmAndHotTiers(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=PoolCacheManager.d.ts.map

package/dist/src/services/PoolCacheManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoolCacheManager.d.ts","sourceRoot":"","sources":["../../../src/services/PoolCacheManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,IAAI,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEtG,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAG/D;;;;GAIG;AACH,KAAK,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAwBzC;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwD;IAEpF,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAIxB;IAEF,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAIvB;IAEF,yBAAyB;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAGhC;gBAGA,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,EAClE,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACnC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,MAAM;IAkBjB;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA2DhE;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,YAAY,GAAG,YAAY,EACtC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO;IAyEV;;;;OAIG;IACH,QAAQ,IAAI;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;KACtB;IAkBD;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM;;;;;;;;;IAiB3B;;;;;;;;OAQG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBlD;;;;;;;;;OASG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAAE,EAClB,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAsChE;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,YAAY,IAAI,IAAI;IAgBpB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAkBrB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAcrB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IA2BhB;;;;;;;OAOG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;CAmC9C"}

package/dist/src/services/PoolService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoolService.d.ts","sourceRoot":"","sources":["../../../src/services/PoolService.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAGL,WAAW,EAEX,gBAAgB,EAIhB,eAAe,EAEf,uBAAuB,EAEvB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,WAAY,SAAQ,WAAW;gBAC9B,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;OAGG;YACW,eAAe;IAwD7B;;;;OAIG;YACW,kBAAkB;IAqGhC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,UAAU,CACd,OAAO,GAAE;QACP,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KACX,GACL,OAAO,CAAC,WAAW,CAAC;IA+IvB;;;;;;;;;;;;;;;;;;OAkBG;IACG,aAAa,CACjB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;KAC7B,GACA,OAAO,CAAC,WAAW,CAAC;IAIvB;;;;;OAKG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAyC5D;;;;;OAKG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW/D;;;;;OAKG;IACG,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW9D;;;;;OAKG;IACG,eAAe,CACnB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,eAAe,CAAC;IAqD3B;;;;;;;;OAQG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,uBAAuB,CAAC;IA4FnC;;;;;;;;OAQG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA4BrE;;;;;OAKG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAkBpE;;;;;;;;;;;;;;;;OAgBG;IACG,uBAAuB,CAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAuB1B"}

package/dist/src/services/PoolStateManager.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Pool State Manager
+ *
+ * Orchestrates efficient pool state tracking through incremental swap deltas
+ * instead of full refetches. Provides the main API for arbitrage bots and other
+ * applications needing real-time pool state with minimal network latency.
+ *
+ * Core features:
+ * - Cached pool state with incremental updates (10-15x faster than full refetches)
+ * - Automatic validation and drift detection
+ * - Graceful fallback to full refetch on errors
+ * - Performance monitoring and metrics
+ * - Support for both exact input and exact output swaps
+ *
+ * Performance: ~30-50ms per swap (vs 200-400ms for full refetch)
+ *
+ * @packageDocumentation
+ */
+import BigNumber from 'bignumber.js';
+import { Pool, TickData } from '@gala-chain/dex';
+import { SwapEventData, SwapDeltaResult, PoolStateMetadata } from '../types/pool-state-delta.dto';
+import { CompositePoolDataResult } from '../types/composite-pool.dto';
+/**
+ * Configuration for PoolStateManager behavior
+ *
+ * @category Pool State Manager
+ */
+export interface PoolStateManagerConfig {
+    /** Safety limit for maximum iterations in swap calculation (default: 100) */
+    maxIterations?: number;
+    /** Enable BigNumber cache for performance (default: true) */
+    enableBigNumberCache?: boolean;
+    /** BigNumber rounding mode (default: ROUND_DOWN) */
+    roundingMode?: BigNumber.RoundingMode;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+    /** Maximum swaps to apply before forcing full refetch (default: 50) */
+    maxSwapsSinceRefetch?: number;
+    /** Maximum cumulative drift percentage before forcing refetch (default: 5%) */
+    maxCumulativeDrift?: number;
+    /**
+     * Callback for when full refetch is needed
+     * Allows client to provide fresh pool data when drift accumulates
+     */
+    onRefetchNeeded?: (pool: Pool, tickDataMap: Record<string, TickData>) => Promise<CompositePoolDataResult>;
+    /**
+     * Enable strict validation mode (default: false)
+     * Throws errors instead of warnings for validation failures
+     */
+    strictValidation?: boolean;
+    /** Enable performance warnings when swap calculation exceeds threshold (default: true) */
+    enablePerformanceWarnings?: boolean;
+    /** Performance warning threshold in milliseconds (default: 100ms) */
+    performanceWarningThreshold?: number;
+}
+/**
+ * Efficient pool state manager using incremental swap deltas
+ *
+ * Main orchestrator for the monkey-patching strategy that avoids full pool refetches.
+ * Coordinates SwapDeltaCalculator, PoolStateValidator, and other utilities to provide
+ * a fast, accurate view of pool state with minimal network calls.
+ *
+ * Usage:
+ * ```typescript
+ * const manager = new PoolStateManager(compositePoolData, config);
+ *
+ * // Apply swaps incrementally (fast - ~30-50ms)
+ * const result = await manager.applySwapDelta(swapEvent);
+ *
+ * // Get current pool state
+ * const currentPool = manager.getPoolState();
+ * const metadata = manager.getMetadata();
+ * ```
+ *
+ * @category Pool State Manager
+ * @since 3.33.0
+ */
+export declare class PoolStateManager {
+    private readonly logger;
+    private readonly config;
+    private readonly validationConfig;
+    /** Current cached pool state */
+    private pool;
+    /** Current tick data map */
+    private tickDataMap;
+    /** Metadata about cache state and drift tracking */
+    private metadata;
+    /** Performance metrics for last swap */
+    private lastSwapMetrics?;
+    /**
+     * Calculate hash of critical pool state for validation
+     *
+     * @param pool Pool to hash
+     * @returns Hash string of pool state
+     */
+    private static calculatePoolStateHash;
+    /**
+     * Initialize PoolStateManager with initial pool state
+     *
+     * @param poolData Initial composite pool data (from fetchCompositePoolData)
+     * @param config Optional configuration overrides
+     * @throws Error if poolData is invalid
+     */
+    constructor(poolData: CompositePoolDataResult, config?: PoolStateManagerConfig);
+    /**
+     * Apply a swap delta to the cached pool state
+     *
+     * Calculates how the swap affects pool state, validates the result,
+     * and updates the cache incrementally. Much faster than full refetch.
+     *
+     * @param swapEvent The swap event to apply
+     * @returns Result with updated pool state and metadata
+     * @throws Error if swap calculation or validation fails (in strict mode)
+     */
+    applySwapDelta(swapEvent: SwapEventData): Promise<SwapDeltaResult>;
+    /**
+     * Force a full refetch of pool state
+     *
+     * Resets all drift tracking and reloads pool state from the provided data.
+     * Use this after receiving a full fetchCompositePoolData response.
+     *
+     * @param poolData Fresh pool data from fetchCompositePoolData
+     */
+    forceFullRefetch(poolData: CompositePoolDataResult): void;
+    /**
+     * Get current pool state
+     *
+     * @returns Current cached Pool object
+     */
+    getPoolState(): Pool;
+    /**
+     * Get current tick data
+     *
+     * @returns Copy of current tick data map
+     */
+    getTickDataMap(): Record<string, TickData>;
+    /**
+     * Get metadata about cache state
+     *
+     * @returns Current PoolStateMetadata
+     */
+    getMetadata(): PoolStateMetadata;
+    /**
+     * Get performance metrics from last swap
+     *
+     * @returns Performance metrics or undefined if no swap applied yet
+     */
+    getLastSwapMetrics(): {
+        calculationTimeMs: number;
+        swapSteps: number;
+        timestamp: number;
+    } | undefined;
+    /**
+     * Check if a full refetch is recommended
+     *
+     * @returns true if drift or swap count thresholds exceeded
+     */
+    isRefetchRecommended(): boolean;
+    /**
+     * Reset the manager to initial state (clears all cached data)
+     *
+     * @param poolData Initial pool data to reload
+     */
+    reset(poolData: CompositePoolDataResult): void;
+}
+/**
+ * Factory function for creating a PoolStateManager instance
+ *
+ * Simplifies initialization by bundling common configuration.
+ *
+ * @param poolData Initial pool data
+ * @param options Configuration options
+ * @returns New PoolStateManager instance
+ */
+export declare function createPoolStateManager(poolData: CompositePoolDataResult, options?: PoolStateManagerConfig): PoolStateManager;
+//# sourceMappingURL=PoolStateManager.d.ts.map

package/dist/src/services/PoolStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoolStateManager.d.ts","sourceRoot":"","sources":["../../../src/services/PoolStateManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAKtE;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,6DAA6D;IAC7D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B,oDAAoD;IACpD,YAAY,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC;IAEtC,4CAA4C;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,uEAAuE;IACvE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,+EAA+E;IAC/E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAE1G;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,0FAA0F;IAC1F,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAEpC,qEAAqE;IACrE,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAE7D,gCAAgC;IAChC,OAAO,CAAC,IAAI,CAAO;IAEnB,4BAA4B;IAC5B,OAAO,CAAC,WAAW,CAA2B;IAE9C,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAoB;IAEpC,wCAAwC;IACxC,OAAO,CAAC,eAAe,CAAC,CAItB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAKrC;;;;;;OAMG;gBACS,QAAQ,EAAE,uBAAuB,EAAE,MAAM,CAAC,EAAE,sBAAsB;IAoE9E;;;;;;;;;OASG;IACG,cAAc,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;IAoKxE;;;;;;;OAOG;IACH,gBAAgB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAYzD;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAIpB;;;;OAIG;IACH,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAI1C;;;;OAIG;IACH,WAAW,IAAI,iBAAiB;IAIhC;;;;OAIG;IACH,kBAAkB,IAAI;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAOrG;;;;OAIG;IACH,oBAAoB,IAAI,OAAO;IAO/B;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;CAgB/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,uBAAuB,EACjC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,gBAAgB,CAElB"}

package/dist/{services → src/services}/PriceHistoryService.d.ts

@@ -31,7 +31,7 @@ import { BaseService } from './BaseService';
  *
  * // Using tokenId
  * const history = await service.fetchPriceHistory({
- *   tokenId: { collection: 'Token', category: 'Unit', type: 'GUSDC', additionalKey: 'eth:...' },
+ *   tokenId: { collection: 'GUSDC', category: 'Unit', type: 'none', additionalKey: 'eth:...' },
  *   from: new Date('2024-01-01'),
  *   to: new Date('2024-01-31'),
  *   page: 1,
@@ -106,10 +106,10 @@ export declare class PriceHistoryService extends BaseService {
      * // Using tokenId object format (explicit, no lookup required)
      * const result = await service.fetchPriceHistory({
      *   tokenId: {
-     *     collection: 'Token',
+     *     collection: 'GUSDC',
      *     category: 'Unit',
-     *     type: 'USDC',
-     *     additionalKey: 'eth:123...'
+     *     type: 'none',
+     *     additionalKey: 'none'
      *   },
      *   from: new Date('2024-01-01'),
      *   to: new Date('2024-01-31'),
@@ -119,7 +119,7 @@ export declare class PriceHistoryService extends BaseService {
      *
      * // Using tokenId string format (backward compatible)
      * const result = await service.fetchPriceHistory({
-     *   tokenId: 'Token|Unit|USDC|eth:123...',
+     *   tokenId: 'GUSDC|Unit|none|none',
      *   page: 1,
      *   limit: 20
      * });

package/dist/src/services/PriceHistoryService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceHistoryService.d.ts","sourceRoot":"","sources":["../../../src/services/PriceHistoryService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAGnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAI9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAmC;IAExE;;;;;OAKG;gBACS,UAAU,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe,EAAE,oBAAoB,CAAC,EAAE,oBAAoB;IAK3G;;;;;;;;;;;;;;;;;;;OAmBG;IACG,6BAA6B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoDvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACG,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkFvF;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IA+B1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACG,oBAAoB,CACxB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,MAAM,GAAG,OAAO,CAAC,GACxD,OAAO,CAAC,kBAAkB,CAAC;IA+B9B;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAgCxB"}

package/dist/{services → src/services}/SignatureService.d.ts

@@ -1,20 +1,17 @@
 /**
  * EIP-712 Signature Service for Bonding Curve Transactions
  *
- * This service handles EIP-712 signature generation for all wallet types
- * supported by the Gala ecosystem. It replicates the exact signature
- * generation process used in the frontend to ensure compatibility.
+ * This service handles EIP-712 signature generation for bonding curve operations
+ * using ethers.js Wallet. It replicates the exact signature generation process
+ * used in the frontend to ensure compatibility with the GalaChain backend.
  *
- * ## Supported Wallets:
- * - MetaMask (signTypedData)
- * - TrustWallet (signMessage with serialization)
- * - GalaWallet (custom implementation)
+ * ## Supported Signing Method:
+ * - ethers.js Wallet (signTypedData)
  *
  * ## Key Features:
  * - Dynamic EIP-712 type generation
  * - Personal sign prefix calculation
- * - Wallet-specific signature handling
- * - Full compatibility with frontend implementation
+ * - Full compatibility with GalaChain backend
  *
  * @category Services
  * @since 2.0.0
@@ -49,14 +46,6 @@ interface EIP712Domain {
     name: string;
     chainId: number;
 }
-/**
- * Wallet preference enumeration
- */
-export declare enum WalletPreference {
-    METAMASK = 0,
-    TRUST_WALLET = 1,
-    GALA_WALLET = 2
-}
 /**
  * Service for handling EIP-712 signatures for bonding curve operations
  */
@@ -64,42 +53,31 @@ export declare class SignatureService extends LoggerBase {
     private walletProvider;
     constructor(walletProvider: WalletProvider, debug?: boolean);
     /**
-     * Sign a DTO using EIP-712 with the appropriate wallet method
+     * Sign a DTO using EIP-712 with ethers.js Wallet
      *
      * @param dto - The DTO to sign (extends ChainCallDTO)
      * @param methodName - The method name for type generation
      * @param walletAddress - The user's wallet address
-     * @param walletPreference - Wallet type preference
      * @returns Signed payload ready for bundle submission
      */
-    signDTO(dto: SignableDTO, methodName: string, walletAddress: string, walletPreference?: WalletPreference): Promise<SignableDTO & {
+    signDTO(dto: SignableDTO, methodName: string, _walletAddress: string): Promise<SignableDTO & {
         signature: string;
         types?: EIP712Types;
         domain?: EIP712Domain;
     }>;
     /**
-     * Sign with MetaMask/ethers.js using signTypedData
-     */
-    private signWithMetaMask;
-    /**
-     * Sign with TrustWallet using signMessage
-     */
-    private signWithTrustWallet;
-    /**
-     * Sign with GalaWallet using custom implementation
-     * Falls back to MetaMask signing in non-browser environments
+     * Sign with ethers.js Wallet using signTypedData
+     *
+     * Supports both direct ethers.js Wallet instances and Web3 providers
+     * with dynamic network detection capabilities.
      */
-    private signWithGalaWallet;
+    private signWithEthersWallet;
     /**
      * Generate EIP-712 types from DTO structure
      * Dynamically creates type definitions based on DTO fields
      * EXACTLY matches frontend implementation from readWriteUtils.ts
      */
     private generateEIP712Types;
-    /**
-     * Detect wallet preference from provider
-     */
-    detectWalletPreference(): WalletPreference;
 }
 export {};
 //# sourceMappingURL=SignatureService.d.ts.map

package/dist/src/services/SignatureService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureService.d.ts","sourceRoot":"","sources":["../../../src/services/SignatureService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQ3C;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CACxE;AAED;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3C;;GAEG;AACH,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAE5C,OAAO,CAAC,cAAc;gBAAd,cAAc,EAAE,cAAc,EACtC,KAAK,GAAE,OAAe;IAKxB;;;;;;;OAOG;IACG,OAAO,CACX,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,WAAW,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;IAoC3F;;;;;OAKG;YACW,oBAAoB;IA8ClC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;CA0F5B"}

package/dist/src/services/SwapEventQueue.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Swap Event Queue
+ *
+ * Manages event queuing with backpressure handling and batch processing.
+ * Prevents memory overflow by dropping events when queue exceeds capacity.
+ *
+ * Features:
+ * - Configurable queue capacity
+ * - Batch processing for efficiency
+ * - Concurrency control
+ * - Automatic metrics tracking
+ * - Graceful shutdown
+ *
+ * @packageDocumentation
+ */
+import type { SwapEventData, SwapMonitorConfig } from '../types/swap-monitor.dto';
+import { Logger } from '../utils/Logger';
+import { MonitoringMetrics } from '../utils/MonitoringMetrics';
+/**
+ * Queue statistics
+ *
+ * @internal
+ */
+export interface QueueStats {
+    queueSize: number;
+    eventsProcessed: number;
+    eventsDropped: number;
+    currentConcurrent: number;
+    maxConcurrentReached: number;
+    averageBatchSize: number;
+    totalBatchesProcessed: number;
+}
+/**
+ * Manages event queue with backpressure and batch processing
+ *
+ * Provides reliable event queuing with overflow protection. Events are processed
+ * in batches to improve efficiency while maintaining concurrency limits.
+ *
+ * @internal
+ */
+export declare class SwapEventQueue {
+    private readonly queue;
+    private readonly config;
+    private readonly metrics;
+    private readonly logger;
+    private isShuttingDown;
+    private currentConcurrency;
+    private maxConcurrencyReached;
+    private eventsDropped;
+    private totalBatchesProcessed;
+    private totalBatchSize;
+    private eventsProcessedCount;
+    /** Processor function - called for each event */
+    private processor;
+    /** Processing loop control */
+    private processingScheduled;
+    /** Cross-platform scheduler */
+    private scheduleProcessing;
+    constructor(config: Required<SwapMonitorConfig>, metrics: MonitoringMetrics, logger?: Logger);
+    /**
+     * Set the event processor function
+     *
+     * @param processor - Function to process each event
+     */
+    setProcessor(processor: (event: SwapEventData) => Promise<void>): void;
+    /**
+     * Enqueue a swap event for processing
+     *
+     * Returns false if queue is full (backpressure), indicating event was dropped.
+     *
+     * @param event - Swap event to queue
+     * @returns True if enqueued, false if dropped due to overflow
+     */
+    enqueue(event: SwapEventData): boolean;
+    /**
+     * Get current queue size
+     *
+     * @returns Number of events waiting to be processed
+     */
+    getQueueSize(): number;
+    /**
+     * Get queue statistics
+     *
+     * @returns Queue stats with metrics
+     */
+    getStats(): QueueStats;
+    /**
+     * Wait for queue to be empty
+     *
+     * @param timeoutMs - Maximum time to wait (default: no timeout)
+     * @returns Promise that resolves when queue is empty or timeout
+     */
+    waitForEmpty(timeoutMs?: number): Promise<void>;
+    /**
+     * Shutdown the queue gracefully
+     *
+     * Stops accepting new events and waits for processing to complete.
+     *
+     * @param timeoutMs - Maximum time to wait for processing to complete (default: 30s)
+     */
+    shutdown(timeoutMs?: number): Promise<void>;
+    /**
+     * Clear the queue without processing
+     *
+     * Use with caution - discards all pending events.
+     */
+    clear(): void;
+    /**
+     * Process next batch of events
+     *
+     * Respects concurrency limits and batch size configuration.
+     *
+     * @internal
+     */
+    private processNextBatch;
+    /**
+     * Process a single event
+     *
+     * @internal
+     */
+    private processEvent;
+}
+//# sourceMappingURL=SwapEventQueue.d.ts.map

package/dist/src/services/SwapEventQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwapEventQueue.d.ts","sourceRoot":"","sources":["../../../src/services/SwapEventQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,oBAAoB,CAAK;IAEjC,iDAAiD;IACjD,OAAO,CAAC,SAAS,CAA0D;IAE3E,8BAA8B;IAC9B,OAAO,CAAC,mBAAmB,CAAS;IAEpC,+BAA+B;IAC/B,OAAO,CAAC,kBAAkB,CAMxB;gBAGA,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACnC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,MAAM;IAWjB;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAItE;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IAgCtC;;;;OAIG;IACH,YAAY,IAAI,MAAM;IAItB;;;;OAIG;IACH,QAAQ,IAAI,UAAU;IAYtB;;;;;OAKG;IACG,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBrD;;;;;;OAMG;IACG,QAAQ,CAAC,SAAS,GAAE,MAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxD;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAQb;;;;;;OAMG;YACW,gBAAgB;IAoE9B;;;;OAIG;YACW,YAAY;CAiB3B"}

package/dist/src/services/TokenClassKeyService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenClassKeyService.d.ts","sourceRoot":"","sources":["../../../src/services/TokenClassKeyService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAU3C;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,UAAU;gBACtC,SAAS,GAAE,OAAe;IAItC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;IAwC3D;;;;;;;OAOG;IACH,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa;IAgBvD;;;;OAIG;IACH,kBAAkB,IAAI,aAAa;IAcnC;;;;;;;;;;;;;OAaG;IACH,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IA0BzD;;;;;OAKG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IA4CnD;;;;;;;;OAQG;IACH,2BAA2B,CACzB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACpB,MAAM;IAIT;;;;;OAKG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG;QAC3C,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;KACvB;CAcF"}

package/dist/{services → src/services}/TokenMetadataCache.d.ts

@@ -261,12 +261,12 @@ export declare class TokenMetadataCache extends LoggerBase {
      * Retrieves cached metadata for a DEX token identified by tokenId (pipe-delimited format).
      * This method is specifically designed for DEX token symbol caching from API responses.
      *
-     * @param tokenId Token ID in pipe-delimited format (e.g., 'Token|Unit|GUSDC|eth:0x...')
+     * @param tokenId Token ID in pipe-delimited format (e.g., 'GUSDC|Unit|none|eth:0x...')
      * @returns Cached metadata or null if not cached
      *
      * @example Retrieving cached DEX token symbol
      * ```typescript
-     * const metadata = cache.getByTokenId('Token|Unit|GUSDC|eth:0x...');
+     * const metadata = cache.getByTokenId('GUSDC|Unit|none|eth:0x...');
      * if (metadata?.symbol) {
      *   console.log(`Symbol: ${metadata.symbol}`);
      * }
@@ -279,12 +279,12 @@ export declare class TokenMetadataCache extends LoggerBase {
      * Caches metadata for a DEX token identified by tokenId (pipe-delimited format).
      * Useful for caching token symbols and other DEX metadata from API responses.
      *
-     * @param tokenId Token ID in pipe-delimited format (e.g., 'Token|Unit|GUSDC|eth:0x...')
+     * @param tokenId Token ID in pipe-delimited format (e.g., 'GUSDC|Unit|none|eth:0x...')
      * @param metadata Partial or complete metadata to cache (merged with existing data)
      *
      * @example Caching DEX token symbol
      * ```typescript
-     * cache.setByTokenId('Token|Unit|GUSDC|eth:0x...', {
+     * cache.setByTokenId('GUSDC|Unit|none|eth:0x...', {
      *   symbol: 'GUSDC'
      * });
      * ```
@@ -293,7 +293,7 @@ export declare class TokenMetadataCache extends LoggerBase {
     /**
      * Check if a tokenId exists in cache (DEX token format)
      *
-     * @param tokenId Token ID in pipe-delimited format (e.g., 'Token|Unit|GUSDC|eth:0x...')
+     * @param tokenId Token ID in pipe-delimited format (e.g., 'GUSDC|Unit|none|eth:0x...')
      * @returns True if tokenId has any cached metadata
      */
     hasByTokenId(tokenId: string): boolean;