keynesol-shared 1.0.0

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/cacheManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Cache Manager
+ * Multi-level caching system for blockchain data
+ * Requirements: 6.2, 6.3
+ */
+export type CacheStrategy = 'lru' | 'lfu' | 'fifo';
+export interface CacheConfig {
+    ttl: number;
+    maxSize?: number;
+    strategy: CacheStrategy;
+}
+export interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    hits: number;
+    ttl: number;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    hitRate: number;
+    size: number;
+    oldestEntry: number;
+    newestEntry: number;
+}
+declare class CacheManager {
+    private caches;
+    private stats;
+    private configs;
+    /**
+     * Get cached data
+     */
+    get<T>(namespace: string, key: string): T | null;
+    /**
+     * Set cached data
+     */
+    set<T>(namespace: string, key: string, data: T, ttl?: number): void;
+    /**
+     * Invalidate cache entry or entire namespace
+     */
+    invalidate(namespace: string, key?: string): void;
+    /**
+     * Clear all caches or specific namespace
+     */
+    clear(namespace?: string): void;
+    /**
+     * Configure cache for namespace
+     */
+    configure(namespace: string, config: CacheConfig): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(namespace: string): CacheStats | null;
+    /**
+     * Evict entry based on strategy
+     */
+    private evict;
+    /**
+     * Record cache hit
+     */
+    private recordHit;
+    /**
+     * Record cache miss
+     */
+    private recordMiss;
+    /**
+     * Clean expired entries (should be called periodically)
+     */
+    cleanExpired(): void;
+}
+export declare const cacheManager: CacheManager;
+export {};
+//# sourceMappingURL=cacheManager.d.ts.map

package/dist/utils/cacheManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheManager.d.ts","sourceRoot":"","sources":["../../src/utils/cacheManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,cAAM,YAAY;IAChB,OAAO,CAAC,MAAM,CAAwD;IACtE,OAAO,CAAC,KAAK,CAA4D;IACzE,OAAO,CAAC,OAAO,CAAuC;IAEtD;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IA4BhD;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IA8BnE;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAWjD;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAU/B;;OAEG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAOvD;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAoB9C;;OAEG;IACH,OAAO,CAAC,KAAK;IAqDb;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,YAAY,IAAI,IAAI;CAYrB;AAGD,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/utils/cacheManager.js

@@ -0,0 +1,232 @@
+/**
+ * Cache Manager
+ * Multi-level caching system for blockchain data
+ * Requirements: 6.2, 6.3
+ */
+class CacheManager {
+    constructor() {
+        this.caches = new Map();
+        this.stats = new Map();
+        this.configs = new Map();
+    }
+    /**
+     * Get cached data
+     */
+    get(namespace, key) {
+        const cache = this.caches.get(namespace);
+        if (!cache) {
+            this.recordMiss(namespace);
+            return null;
+        }
+        const entry = cache.get(key);
+        if (!entry) {
+            this.recordMiss(namespace);
+            return null;
+        }
+        // Check if entry is expired
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+            cache.delete(key);
+            this.recordMiss(namespace);
+            return null;
+        }
+        // Update hit count
+        entry.hits++;
+        this.recordHit(namespace);
+        return entry.data;
+    }
+    /**
+     * Set cached data
+     */
+    set(namespace, key, data, ttl) {
+        const config = this.configs.get(namespace);
+        if (!config) {
+            console.warn(`No config found for namespace: ${namespace}`);
+            return;
+        }
+        let cache = this.caches.get(namespace);
+        if (!cache) {
+            cache = new Map();
+            this.caches.set(namespace, cache);
+            this.stats.set(namespace, { hits: 0, misses: 0 });
+        }
+        const entryTtl = ttl || config.ttl;
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            hits: 0,
+            ttl: entryTtl,
+        };
+        // Check max size and evict if needed
+        if (config.maxSize && cache.size >= config.maxSize) {
+            this.evict(namespace, cache, config.strategy);
+        }
+        cache.set(key, entry);
+    }
+    /**
+     * Invalidate cache entry or entire namespace
+     */
+    invalidate(namespace, key) {
+        const cache = this.caches.get(namespace);
+        if (!cache)
+            return;
+        if (key) {
+            cache.delete(key);
+        }
+        else {
+            cache.clear();
+        }
+    }
+    /**
+     * Clear all caches or specific namespace
+     */
+    clear(namespace) {
+        if (namespace) {
+            this.caches.delete(namespace);
+            this.stats.delete(namespace);
+        }
+        else {
+            this.caches.clear();
+            this.stats.clear();
+        }
+    }
+    /**
+     * Configure cache for namespace
+     */
+    configure(namespace, config) {
+        this.configs.set(namespace, config);
+        if (!this.stats.has(namespace)) {
+            this.stats.set(namespace, { hits: 0, misses: 0 });
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats(namespace) {
+        const cache = this.caches.get(namespace);
+        const stats = this.stats.get(namespace);
+        if (!cache || !stats)
+            return null;
+        const entries = Array.from(cache.values());
+        const timestamps = entries.map(e => e.timestamp);
+        const totalRequests = stats.hits + stats.misses;
+        const hitRate = totalRequests > 0 ? stats.hits / totalRequests : 0;
+        return {
+            hits: stats.hits,
+            misses: stats.misses,
+            hitRate,
+            size: cache.size,
+            oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : 0,
+            newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : 0,
+        };
+    }
+    /**
+     * Evict entry based on strategy
+     */
+    evict(namespace, cache, strategy) {
+        let entryToEvict = null;
+        switch (strategy) {
+            case 'lru': {
+                // Evict least recently used (oldest timestamp)
+                let oldestTime = Infinity;
+                const entries = Array.from(cache.entries());
+                for (const [key, entry] of entries) {
+                    if (entry.timestamp < oldestTime) {
+                        oldestTime = entry.timestamp;
+                        entryToEvict = key;
+                    }
+                }
+                break;
+            }
+            case 'lfu': {
+                // Evict least frequently used (lowest hits)
+                let lowestHits = Infinity;
+                const entries = Array.from(cache.entries());
+                for (const [key, entry] of entries) {
+                    if (entry.hits < lowestHits) {
+                        lowestHits = entry.hits;
+                        entryToEvict = key;
+                    }
+                }
+                break;
+            }
+            case 'fifo': {
+                // Evict first in (oldest timestamp, same as LRU for simplicity)
+                let oldestTime = Infinity;
+                const entries = Array.from(cache.entries());
+                for (const [key, entry] of entries) {
+                    if (entry.timestamp < oldestTime) {
+                        oldestTime = entry.timestamp;
+                        entryToEvict = key;
+                    }
+                }
+                break;
+            }
+        }
+        if (entryToEvict) {
+            cache.delete(entryToEvict);
+        }
+    }
+    /**
+     * Record cache hit
+     */
+    recordHit(namespace) {
+        const stats = this.stats.get(namespace);
+        if (stats) {
+            stats.hits++;
+        }
+    }
+    /**
+     * Record cache miss
+     */
+    recordMiss(namespace) {
+        const stats = this.stats.get(namespace);
+        if (stats) {
+            stats.misses++;
+        }
+    }
+    /**
+     * Clean expired entries (should be called periodically)
+     */
+    cleanExpired() {
+        const now = Date.now();
+        const namespaces = Array.from(this.caches.entries());
+        for (const [namespace, cache] of namespaces) {
+            const entries = Array.from(cache.entries());
+            for (const [key, entry] of entries) {
+                if (now - entry.timestamp > entry.ttl) {
+                    cache.delete(key);
+                }
+            }
+        }
+    }
+}
+// Export singleton instance
+export const cacheManager = new CacheManager();
+// Configure default caches
+cacheManager.configure('vaults', {
+    ttl: 30000, // 30 seconds
+    maxSize: 100,
+    strategy: 'lru',
+});
+cacheManager.configure('userStakes', {
+    ttl: 10000, // 10 seconds
+    maxSize: 1000,
+    strategy: 'lru',
+});
+cacheManager.configure('platformMetrics', {
+    ttl: 60000, // 1 minute
+    maxSize: 50,
+    strategy: 'lru',
+});
+cacheManager.configure('transactions', {
+    ttl: 60000, // 1 minute
+    maxSize: 500,
+    strategy: 'lru',
+});
+// Clean expired entries every 5 minutes
+if (typeof window !== 'undefined') {
+    setInterval(() => {
+        cacheManager.cleanExpired();
+    }, 5 * 60 * 1000);
+}

package/dist/utils/errorHandler.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Error Handler Utility
+ * Comprehensive error handling system with classification, retry logic, and user-friendly messages
+ * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5
+ */
+export declare enum ErrorCategory {
+    NETWORK = "network",
+    BLOCKCHAIN = "blockchain",
+    VALIDATION = "validation",
+    AUTHORIZATION = "authorization",
+    DATA = "data",
+    UNKNOWN = "unknown"
+}
+export interface ErrorHandlerConfig {
+    retryAttempts?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+export interface ErrorLog {
+    timestamp: number;
+    level: 'error' | 'warning' | 'info';
+    context: string;
+    message: string;
+    stack?: string;
+    metadata?: Record<string, any>;
+    userId?: string;
+    category: ErrorCategory;
+}
+declare class ErrorHandler {
+    private logs;
+    private maxLogs;
+    /**
+     * Classify error into category
+     */
+    classifyError(error: Error): ErrorCategory;
+    /**
+     * Get user-friendly error message
+     */
+    getErrorMessage(error: Error): string;
+    /**
+     * Get recovery suggestion based on error category
+     */
+    getRecoverySuggestion(error: Error): string | null;
+    /**
+     * Log error with context
+     */
+    logError(error: Error, context: string, metadata?: Record<string, any>): void;
+    /**
+     * Wrap async function with error handling and retry logic
+     */
+    wrapAsync<T>(fn: () => Promise<T>, config?: ErrorHandlerConfig): Promise<T>;
+    /**
+     * Handle error with appropriate recovery strategy
+     */
+    handleError(error: Error, context: string, config?: ErrorHandlerConfig): void;
+    /**
+     * Get recent errors for debugging
+     */
+    getRecentErrors(count?: number): ErrorLog[];
+    /**
+     * Clear error logs
+     */
+    clearLogs(): void;
+    /**
+     * Get current user ID (if available)
+     */
+    private getCurrentUserId;
+    /**
+     * Send error to monitoring service
+     */
+    private sendToMonitoring;
+}
+export declare const errorHandler: ErrorHandler;
+export {};
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/utils/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/utils/errorHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oBAAY,aAAa;IACvB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACnD;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,cAAM,YAAY;IAChB,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAE/B;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa;IAgE1C;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAiDrC;;OAEG;IACH,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI;IAwBlD;;OAEG;IACH,QAAQ,CACN,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC7B,IAAI;IA8BP;;OAEG;IACG,SAAS,CAAC,CAAC,EACf,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,OAAO,CAAC,CAAC,CAAC;IAgDb;;OAEG;IACH,WAAW,CACT,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,kBAAkB,GAC1B,IAAI;IAYP;;OAEG;IACH,eAAe,CAAC,KAAK,GAAE,MAAW,GAAG,QAAQ,EAAE;IAI/C;;OAEG;IACH,SAAS,IAAI,IAAI;IAIjB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;YACW,gBAAgB;CAU/B;AAGD,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/utils/errorHandler.js

@@ -0,0 +1,267 @@
+/**
+ * Error Handler Utility
+ * Comprehensive error handling system with classification, retry logic, and user-friendly messages
+ * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["NETWORK"] = "network";
+    ErrorCategory["BLOCKCHAIN"] = "blockchain";
+    ErrorCategory["VALIDATION"] = "validation";
+    ErrorCategory["AUTHORIZATION"] = "authorization";
+    ErrorCategory["DATA"] = "data";
+    ErrorCategory["UNKNOWN"] = "unknown";
+})(ErrorCategory || (ErrorCategory = {}));
+class ErrorHandler {
+    constructor() {
+        this.logs = [];
+        this.maxLogs = 1000;
+    }
+    /**
+     * Classify error into category
+     */
+    classifyError(error) {
+        var _a;
+        const message = error.message.toLowerCase();
+        const stack = ((_a = error.stack) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+        // Network errors
+        if (message.includes('network') ||
+            message.includes('fetch') ||
+            message.includes('timeout') ||
+            message.includes('connection') ||
+            message.includes('rpc') ||
+            message.includes('failed to fetch')) {
+            return ErrorCategory.NETWORK;
+        }
+        // Blockchain errors
+        if (message.includes('transaction') ||
+            message.includes('insufficient') ||
+            message.includes('program') ||
+            message.includes('account') ||
+            message.includes('anchor') ||
+            message.includes('solana')) {
+            return ErrorCategory.BLOCKCHAIN;
+        }
+        // Validation errors
+        if (message.includes('invalid') ||
+            message.includes('required') ||
+            message.includes('must be') ||
+            message.includes('out of range') ||
+            message.includes('validation')) {
+            return ErrorCategory.VALIDATION;
+        }
+        // Authorization errors
+        if (message.includes('unauthorized') ||
+            message.includes('permission') ||
+            message.includes('access denied') ||
+            message.includes('wallet not connected') ||
+            message.includes('signature')) {
+            return ErrorCategory.AUTHORIZATION;
+        }
+        // Data errors
+        if (message.includes('parse') ||
+            message.includes('json') ||
+            message.includes('data') ||
+            message.includes('supabase') ||
+            message.includes('database')) {
+            return ErrorCategory.DATA;
+        }
+        return ErrorCategory.UNKNOWN;
+    }
+    /**
+     * Get user-friendly error message
+     */
+    getErrorMessage(error) {
+        const category = this.classifyError(error);
+        const message = error.message;
+        switch (category) {
+            case ErrorCategory.NETWORK:
+                if (message.includes('timeout')) {
+                    return 'Connection timeout. Please check your internet connection and try again.';
+                }
+                if (message.includes('rpc')) {
+                    return 'Blockchain connection failed. Please try again in a moment.';
+                }
+                return 'Network error. Please check your connection and try again.';
+            case ErrorCategory.BLOCKCHAIN:
+                if (message.includes('insufficient')) {
+                    return 'Insufficient balance. Please add more tokens to your wallet.';
+                }
+                if (message.includes('user rejected')) {
+                    return 'Transaction cancelled.';
+                }
+                if (message.includes('slippage')) {
+                    return 'Transaction failed due to price movement. Please try again.';
+                }
+                if (message.includes('simulation')) {
+                    return 'Transaction simulation failed. Please check your inputs and try again.';
+                }
+                return 'Transaction failed. Please try again or contact support if the issue persists.';
+            case ErrorCategory.VALIDATION:
+                return message || 'Invalid input. Please check your values and try again.';
+            case ErrorCategory.AUTHORIZATION:
+                if (message.includes('wallet not connected')) {
+                    return 'Please connect your wallet to continue.';
+                }
+                if (message.includes('unauthorized')) {
+                    return 'You do not have permission to perform this action.';
+                }
+                return 'Authorization required. Please connect your wallet.';
+            case ErrorCategory.DATA:
+                return 'Data error. Please refresh the page and try again.';
+            default:
+                return message || 'An unexpected error occurred. Please try again.';
+        }
+    }
+    /**
+     * Get recovery suggestion based on error category
+     */
+    getRecoverySuggestion(error) {
+        const category = this.classifyError(error);
+        switch (category) {
+            case ErrorCategory.NETWORK:
+                return 'Check your internet connection and try again. If the problem persists, try refreshing the page.';
+            case ErrorCategory.BLOCKCHAIN:
+                return 'Verify your wallet has sufficient balance and try again. If the issue continues, check the transaction on Solana Explorer.';
+            case ErrorCategory.VALIDATION:
+                return 'Please review your inputs and ensure all required fields are filled correctly.';
+            case ErrorCategory.AUTHORIZATION:
+                return 'Please connect your wallet and ensure you have the necessary permissions.';
+            case ErrorCategory.DATA:
+                return 'Try refreshing the page. If the problem persists, contact support.';
+            default:
+                return null;
+        }
+    }
+    /**
+     * Log error with context
+     */
+    logError(error, context, metadata) {
+        var _a, _b;
+        const category = this.classifyError(error);
+        const errorLog = {
+            timestamp: Date.now(),
+            level: 'error',
+            context,
+            message: error.message,
+            stack: error.stack,
+            metadata,
+            userId: this.getCurrentUserId(),
+            category,
+        };
+        // Add to in-memory log
+        this.logs.push(errorLog);
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        // Log to console in development
+        if (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) === 'development') {
+            console.error(`[${context}]`, error, metadata);
+        }
+        // Send to monitoring service in production
+        if (typeof process !== 'undefined' && ((_b = process.env) === null || _b === void 0 ? void 0 : _b.NODE_ENV) === 'production') {
+            this.sendToMonitoring(errorLog);
+        }
+    }
+    /**
+     * Wrap async function with error handling and retry logic
+     */
+    wrapAsync(fn, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { retryAttempts = 3, retryDelay = 1000, exponentialBackoff = true, onRetry, } = config || {};
+            let lastError;
+            let attempt = 0;
+            while (attempt < retryAttempts) {
+                try {
+                    return yield fn();
+                }
+                catch (error) {
+                    lastError = error;
+                    attempt++;
+                    // Don't retry validation errors
+                    if (this.classifyError(lastError) === ErrorCategory.VALIDATION) {
+                        throw lastError;
+                    }
+                    // Don't retry on final attempt
+                    if (attempt >= retryAttempts) {
+                        break;
+                    }
+                    // Calculate delay with exponential backoff
+                    const delay = exponentialBackoff
+                        ? retryDelay * Math.pow(2, attempt - 1)
+                        : retryDelay;
+                    // Add jitter to prevent thundering herd
+                    const jitter = Math.random() * 500;
+                    // Call retry callback
+                    if (onRetry) {
+                        onRetry(attempt, lastError);
+                    }
+                    yield new Promise((resolve) => setTimeout(resolve, delay + jitter));
+                }
+            }
+            throw lastError;
+        });
+    }
+    /**
+     * Handle error with appropriate recovery strategy
+     */
+    handleError(error, context, config) {
+        this.logError(error, context);
+        const category = this.classifyError(error);
+        const message = this.getErrorMessage(error);
+        const suggestion = this.getRecoverySuggestion(error);
+        // In a real implementation, this would trigger toast notifications
+        // For now, we'll just log it
+        console.error(`[${context}] ${message}`, suggestion ? `Suggestion: ${suggestion}` : '');
+    }
+    /**
+     * Get recent errors for debugging
+     */
+    getRecentErrors(count = 10) {
+        return this.logs.slice(-count);
+    }
+    /**
+     * Clear error logs
+     */
+    clearLogs() {
+        this.logs = [];
+    }
+    /**
+     * Get current user ID (if available)
+     */
+    getCurrentUserId() {
+        // In a real implementation, this would get the current user's public key
+        if (typeof window !== 'undefined') {
+            // Could get from wallet connection state
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Send error to monitoring service
+     */
+    sendToMonitoring(errorLog) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // In production, send to monitoring service (e.g., Sentry, LogRocket)
+            // For now, we'll just store it locally
+            try {
+                // Could send to Supabase or external service
+                // await supabase.from('error_logs').insert(errorLog);
+            }
+            catch (e) {
+                console.error('Failed to send error to monitoring:', e);
+            }
+        });
+    }
+}
+// Export singleton instance
+export const errorHandler = new ErrorHandler();

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utils Index
+ * Export all utility functions
+ */
+export * from './errorHandler';
+export * from './cacheManager';
+export * from './tokenUtils';
+export * from './validation';
+export * from './toastService';
+export * from './rpcRetry';
+export * from './performanceMonitor';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,11 @@
+/**
+ * Utils Index
+ * Export all utility functions
+ */
+export * from './errorHandler';
+export * from './cacheManager';
+export * from './tokenUtils';
+export * from './validation';
+export * from './toastService';
+export * from './rpcRetry';
+export * from './performanceMonitor';