@gvnrdao/dh-lit-actions 0.0.3 → 0.0.5

package/pkg-dist/utils/chunks/error-classification.js

@@ -0,0 +1,385 @@
+"use strict";
+/**
+ * Enhanced Error Classification for LIT Protocol Operations
+ * Provides detailed error categorization and specific retry strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.litProtocolErrors = exports.RetryStrategy = exports.ErrorCategory = void 0;
+exports.classifyError = classifyError;
+exports.getRetryConfigFromClassification = getRetryConfigFromClassification;
+exports.analyzeError = analyzeError;
+exports.createErrorReport = createErrorReport;
+/**
+ * Error categories for different types of failures
+ */
+var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["NETWORK"] = "network";
+    ErrorCategory["PROTOCOL"] = "protocol";
+    ErrorCategory["AUTHENTICATION"] = "authentication";
+    ErrorCategory["RESOURCE"] = "resource";
+    ErrorCategory["VALIDATION"] = "validation";
+    ErrorCategory["TIMEOUT"] = "timeout";
+    ErrorCategory["RATE_LIMIT"] = "rate_limit";
+    ErrorCategory["CONFIGURATION"] = "configuration";
+    ErrorCategory["UNKNOWN"] = "unknown";
+})(ErrorCategory || (exports.ErrorCategory = ErrorCategory = {}));
+/**
+ * Retry strategy types
+ */
+var RetryStrategy;
+(function (RetryStrategy) {
+    RetryStrategy["AGGRESSIVE"] = "aggressive";
+    RetryStrategy["CONSERVATIVE"] = "conservative";
+    RetryStrategy["EXPONENTIAL"] = "exponential";
+    RetryStrategy["LINEAR"] = "linear";
+    RetryStrategy["NONE"] = "none"; // No retries
+})(RetryStrategy || (exports.RetryStrategy = RetryStrategy = {}));
+/**
+ * LIT Protocol specific error patterns
+ */
+const LIT_ERROR_PATTERNS = {
+    // Network and connection errors
+    network: [
+        /network error/i,
+        /connection failed/i,
+        /connection refused/i,
+        /connection timeout/i,
+        /socket hang up/i,
+        /enotfound/i,
+        /econnrefused/i,
+        /etimedout/i,
+        /dns resolution failed/i,
+        /request failed/i
+    ],
+    // Protocol specific errors
+    protocol: [
+        /lit protocol/i,
+        /lit node/i,
+        /signing shares/i,
+        /node communication/i,
+        /consensus/i,
+        /threshold/i,
+        /decryption/i,
+        /signature verification/i,
+        /There was an error getting the signing shares/i,
+        /Response from the nodes/i,
+        /NodeError/i,
+        /PKP validation/i,
+        /pkp validation failed/i
+    ],
+    // Authentication and authorization errors
+    authentication: [
+        /authentication/i,
+        /authorization/i,
+        /session.*expired/i,
+        /invalid.*signature/i,
+        /unauthorized/i,
+        /access.*denied/i,
+        /permission/i,
+        /auth.*failed/i,
+        /siwe/i,
+        /session.*sig/i
+    ],
+    // Resource and validation errors
+    resource: [
+        /resource.*not.*found/i,
+        /ipfs.*not.*found/i,
+        /cid.*invalid/i,
+        /pkp.*not.*found/i,
+        /pkp.*validation/i,
+        /resource.*validation/i,
+        /action.*not.*permitted/i,
+        /lit.*action.*not.*found/i
+    ],
+    // Validation errors
+    validation: [
+        /validation.*failed/i,
+        /invalid.*input/i,
+        /invalid.*parameter/i,
+        /malformed/i,
+        /schema.*validation/i,
+        /type.*error/i,
+        /missing.*required/i
+    ],
+    // Timeout specific errors
+    timeout: [
+        /timeout/i,
+        /request.*timed.*out/i,
+        /operation.*timed.*out/i,
+        /deadline.*exceeded/i,
+        /time.*limit.*exceeded/i
+    ],
+    // Rate limiting errors
+    rateLimit: [
+        /rate.*limit/i,
+        /too.*many.*requests/i,
+        /quota.*exceeded/i,
+        /throttled/i,
+        /429/,
+        /rate.*exceeded/i
+    ],
+    // Configuration errors
+    configuration: [
+        /configuration/i,
+        /config.*error/i,
+        /environment/i,
+        /missing.*env/i,
+        /invalid.*config/i,
+        /setup.*error/i
+    ]
+};
+/**
+ * Predefined retry strategies
+ */
+const RETRY_STRATEGIES = {
+    [RetryStrategy.AGGRESSIVE]: {
+        maxAttempts: 5,
+        baseDelayMs: 500,
+        maxDelayMs: 5000,
+        multiplier: 1.5
+    },
+    [RetryStrategy.CONSERVATIVE]: {
+        maxAttempts: 3,
+        baseDelayMs: 3000,
+        maxDelayMs: 30000,
+        multiplier: 2.5
+    },
+    [RetryStrategy.EXPONENTIAL]: {
+        maxAttempts: 4,
+        baseDelayMs: 1000,
+        maxDelayMs: 15000,
+        multiplier: 2.0
+    },
+    [RetryStrategy.LINEAR]: {
+        maxAttempts: 3,
+        baseDelayMs: 2000,
+        maxDelayMs: 10000,
+        multiplier: 1.0
+    },
+    [RetryStrategy.NONE]: {
+        maxAttempts: 1,
+        baseDelayMs: 0,
+        maxDelayMs: 0,
+        multiplier: 1.0
+    }
+};
+/**
+ * Error classification rules
+ */
+const CLASSIFICATION_RULES = {
+    [ErrorCategory.NETWORK]: {
+        category: ErrorCategory.NETWORK,
+        retryStrategy: RetryStrategy.AGGRESSIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.AGGRESSIVE],
+        description: 'Network connectivity or communication error',
+        troubleshooting: [
+            'Check internet connection',
+            'Verify LIT Protocol network status',
+            'Check firewall and proxy settings',
+            'Try connecting to different node endpoints'
+        ]
+    },
+    [ErrorCategory.PROTOCOL]: {
+        category: ErrorCategory.PROTOCOL,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        description: 'LIT Protocol specific operational error',
+        troubleshooting: [
+            'Check LIT Protocol network status',
+            'Verify PKP configuration',
+            'Check signing shares availability',
+            'Wait for network consensus'
+        ]
+    },
+    [ErrorCategory.AUTHENTICATION]: {
+        category: ErrorCategory.AUTHENTICATION,
+        retryStrategy: RetryStrategy.EXPONENTIAL,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.EXPONENTIAL],
+        maxAttempts: 2, // Override: limited retries for auth issues
+        description: 'Authentication or authorization error',
+        troubleshooting: [
+            'Check session signatures validity',
+            'Regenerate authentication tokens',
+            'Verify wallet permissions',
+            'Check PKP authorization status'
+        ]
+    },
+    [ErrorCategory.RESOURCE]: {
+        category: ErrorCategory.RESOURCE,
+        retryStrategy: RetryStrategy.LINEAR,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.LINEAR],
+        maxAttempts: 2, // Override: limited retries for resource issues
+        description: 'Resource not found or validation error',
+        troubleshooting: [
+            'Verify resource CIDs are correct',
+            'Check IPFS availability',
+            'Confirm PKP exists and is accessible',
+            'Wait for resource propagation'
+        ]
+    },
+    [ErrorCategory.VALIDATION]: {
+        category: ErrorCategory.VALIDATION,
+        retryStrategy: RetryStrategy.NONE,
+        isRetryable: false,
+        ...RETRY_STRATEGIES[RetryStrategy.NONE],
+        description: 'Input validation or schema error',
+        troubleshooting: [
+            'Check input parameters format',
+            'Verify required fields are provided',
+            'Validate data types and ranges',
+            'Review API documentation'
+        ]
+    },
+    [ErrorCategory.TIMEOUT]: {
+        category: ErrorCategory.TIMEOUT,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        description: 'Operation timeout error',
+        troubleshooting: [
+            'Increase timeout values',
+            'Check network latency',
+            'Verify system resources',
+            'Split operations into smaller chunks'
+        ]
+    },
+    [ErrorCategory.RATE_LIMIT]: {
+        category: ErrorCategory.RATE_LIMIT,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        maxAttempts: 2, // Override: limited retries to avoid further rate limiting
+        baseDelayMs: 5000, // Override: longer delays for rate limits
+        description: 'Rate limit or quota exceeded',
+        troubleshooting: [
+            'Reduce request frequency',
+            'Implement request batching',
+            'Check rate limit headers',
+            'Wait for quota reset'
+        ]
+    },
+    [ErrorCategory.CONFIGURATION]: {
+        category: ErrorCategory.CONFIGURATION,
+        retryStrategy: RetryStrategy.NONE,
+        isRetryable: false,
+        ...RETRY_STRATEGIES[RetryStrategy.NONE],
+        description: 'Configuration or setup error',
+        troubleshooting: [
+            'Check environment variables',
+            'Verify configuration files',
+            'Review setup documentation',
+            'Check required dependencies'
+        ]
+    },
+    [ErrorCategory.UNKNOWN]: {
+        category: ErrorCategory.UNKNOWN,
+        retryStrategy: RetryStrategy.EXPONENTIAL,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.EXPONENTIAL],
+        maxAttempts: 2, // Override: conservative retries for unknown errors
+        description: 'Unknown or unclassified error',
+        troubleshooting: [
+            'Check logs for more details',
+            'Verify system status',
+            'Try again with debug logging',
+            'Contact support if persists'
+        ]
+    }
+};
+/**
+ * Classify an error and determine retry strategy
+ */
+function classifyError(error) {
+    const errorMessage = error?.message || error?.toString() || '';
+    const errorLower = errorMessage.toLowerCase();
+    // Check each error category
+    for (const [category, patterns] of Object.entries(LIT_ERROR_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (pattern.test(errorMessage) || pattern.test(errorLower)) {
+                const classification = CLASSIFICATION_RULES[category];
+                return {
+                    ...classification,
+                    description: `${classification.description}: ${errorMessage.slice(0, 100)}`
+                };
+            }
+        }
+    }
+    // Default to unknown category
+    const unknownClassification = CLASSIFICATION_RULES[ErrorCategory.UNKNOWN];
+    return {
+        ...unknownClassification,
+        description: `${unknownClassification.description}: ${errorMessage.slice(0, 100)}`
+    };
+}
+/**
+ * Get retry configuration from error classification
+ */
+function getRetryConfigFromClassification(classification) {
+    return {
+        maxAttempts: classification.maxAttempts,
+        initialDelayMs: classification.baseDelayMs,
+        maxDelayMs: classification.maxDelayMs,
+        backoffMultiplier: RETRY_STRATEGIES[classification.retryStrategy].multiplier,
+        retryableErrors: ['*'] // Classification already determined retryability
+    };
+}
+/**
+ * Enhanced error analyzer for detailed error information
+ */
+function analyzeError(error) {
+    const classification = classifyError(error);
+    return {
+        ...classification,
+        originalError: error,
+        errorMessage: error?.message || error?.toString() || 'Unknown error',
+        errorStack: error?.stack,
+        timestamp: new Date().toISOString(),
+        retryConfig: getRetryConfigFromClassification(classification)
+    };
+}
+/**
+ * Create a human-readable error report
+ */
+function createErrorReport(error) {
+    const analysis = analyzeError(error);
+    const report = [
+        `🔍 Error Analysis Report`,
+        `=====================================`,
+        `Category: ${analysis.category.toUpperCase()}`,
+        `Retryable: ${analysis.isRetryable ? '✅ Yes' : '❌ No'}`,
+        `Strategy: ${analysis.retryStrategy}`,
+        `Max Attempts: ${analysis.maxAttempts}`,
+        `Description: ${analysis.description}`,
+        `Timestamp: ${analysis.timestamp}`,
+        ``,
+        `Original Error: ${analysis.errorMessage}`,
+        ``
+    ];
+    if (analysis.troubleshooting && analysis.troubleshooting.length > 0) {
+        report.push(`🛠️  Troubleshooting Steps:`);
+        analysis.troubleshooting.forEach((step, index) => {
+            report.push(`   ${index + 1}. ${step}`);
+        });
+        report.push('');
+    }
+    return report.join('\n');
+}
+/**
+ * LIT Protocol specific error matchers
+ */
+exports.litProtocolErrors = {
+    isNetworkError: (error) => classifyError(error).category === ErrorCategory.NETWORK,
+    isProtocolError: (error) => classifyError(error).category === ErrorCategory.PROTOCOL,
+    isAuthenticationError: (error) => classifyError(error).category === ErrorCategory.AUTHENTICATION,
+    isResourceError: (error) => classifyError(error).category === ErrorCategory.RESOURCE,
+    isTimeoutError: (error) => classifyError(error).category === ErrorCategory.TIMEOUT,
+    isRateLimitError: (error) => classifyError(error).category === ErrorCategory.RATE_LIMIT,
+    isConfigurationError: (error) => classifyError(error).category === ErrorCategory.CONFIGURATION,
+    isRetryable: (error) => classifyError(error).isRetryable
+};
+//# sourceMappingURL=error-classification.js.map

package/pkg-dist/utils/chunks/error-classification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-classification.js","sourceRoot":"","sources":["../../../pkg-src/utils/chunks/error-classification.ts"],"names":[],"mappings":"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"}

package/pkg-dist/utils/chunks/session-signature-cache.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Session Signature Cache for PKP Operations
+ * Provides intelligent caching of session signatures to avoid regeneration
+ */
+/**
+ * Session signature cache configuration
+ */
+export interface SessionSignatureCacheConfig {
+    maxEntries: number;
+    bufferTimeMs: number;
+    enableLogging: boolean;
+}
+export declare const DEFAULT_CACHE_CONFIG: SessionSignatureCacheConfig;
+/**
+ * In-memory session signature cache
+ */
+declare class SessionSignatureCache {
+    private cache;
+    private config;
+    constructor(config?: Partial<SessionSignatureCacheConfig>);
+    /**
+     * Generate cache key from PKP and context
+     */
+    private generateCacheKey;
+    /**
+     * Check if cache entry is still valid
+     */
+    private isEntryValid;
+    /**
+     * Clean expired entries from cache
+     */
+    private cleanExpiredEntries;
+    /**
+     * Enforce cache size limits
+     */
+    private enforceCacheSize;
+    /**
+     * Get cached session signatures if valid
+     */
+    get(pkpTokenId: string, litActionCid: string, signerAddress: string, network: string): any | null;
+    /**
+     * Cache session signatures
+     */
+    set(pkpTokenId: string, litActionCid: string, signerAddress: string, network: string, sessionSigs: any, expiration: Date): void;
+    /**
+     * Clear all cached session signatures
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxEntries: number;
+        utilizationPercent: number;
+    };
+    /**
+     * Remove specific cache entry
+     */
+    delete(pkpTokenId: string, litActionCid: string, signerAddress: string, network: string): boolean;
+}
+export declare const sessionSignatureCache: SessionSignatureCache;
+/**
+ * Enhanced session signature generator with caching
+ */
+export declare function generateSessionSignaturesWithCache(litNodeClient: any, sessionConfig: any, pkpTokenId: string, litActionCid: string, signerAddress: string, network?: string): Promise<any>;
+/**
+ * Configure the global session signature cache
+ */
+export declare function configureSessionSignatureCache(config: Partial<SessionSignatureCacheConfig>): void;
+/**
+ * Clear the global session signature cache
+ */
+export declare function clearSessionSignatureCache(): void;
+/**
+ * Get session signature cache statistics
+ */
+export declare function getSessionSignatureCacheStats(): {
+    size: number;
+    maxEntries: number;
+    utilizationPercent: number;
+};
+export {};
+//# sourceMappingURL=session-signature-cache.d.ts.map

package/pkg-dist/utils/chunks/session-signature-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-signature-cache.d.ts","sourceRoot":"","sources":["../../../pkg-src/utils/chunks/session-signature-cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,oBAAoB,EAAE,2BAIlC,CAAC;AAEF;;GAEG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,KAAK,CAAiD;IAC9D,OAAO,CAAC,MAAM,CAA8B;gBAEhC,MAAM,GAAE,OAAO,CAAC,2BAA2B,CAAM;IAI7D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;OAEG;IACH,GAAG,CACD,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GACd,GAAG,GAAG,IAAI;IA6Bb;;OAEG;IACH,GAAG,CACD,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,GAAG,EAChB,UAAU,EAAE,IAAI,GACf,IAAI;IAuBP;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,QAAQ;;;;;IAUR;;OAEG;IACH,MAAM,CACJ,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GACd,OAAO;CAUX;AAGD,eAAO,MAAM,qBAAqB,uBAA8B,CAAC;AAEjE;;GAEG;AACH,wBAAsB,kCAAkC,CACtD,aAAa,EAAE,GAAG,EAClB,aAAa,EAAE,GAAG,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,MAAgB,GACxB,OAAO,CAAC,GAAG,CAAC,CAqBd;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,CAEjG;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAED;;GAEG;AACH,wBAAgB,6BAA6B;;;;EAE5C"}

package/pkg-dist/utils/chunks/session-signature-cache.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Session Signature Cache for PKP Operations
+ * Provides intelligent caching of session signatures to avoid regeneration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionSignatureCache = exports.DEFAULT_CACHE_CONFIG = void 0;
+exports.generateSessionSignaturesWithCache = generateSessionSignaturesWithCache;
+exports.configureSessionSignatureCache = configureSessionSignatureCache;
+exports.clearSessionSignatureCache = clearSessionSignatureCache;
+exports.getSessionSignatureCacheStats = getSessionSignatureCacheStats;
+const debug_logger_1 = require("./debug-logger");
+exports.DEFAULT_CACHE_CONFIG = {
+    maxEntries: 50,
+    bufferTimeMs: 60000, // 1 minute buffer before expiration
+    enableLogging: true
+};
+/**
+ * In-memory session signature cache
+ */
+class SessionSignatureCache {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.config = { ...exports.DEFAULT_CACHE_CONFIG, ...config };
+    }
+    /**
+     * Generate cache key from PKP and context
+     */
+    generateCacheKey(pkpTokenId, litActionCid, signerAddress, network) {
+        return `${signerAddress}-${network}-${pkpTokenId}-${litActionCid}`;
+    }
+    /**
+     * Check if cache entry is still valid
+     */
+    isEntryValid(entry) {
+        const now = new Date();
+        const expirationWithBuffer = new Date(entry.expiration.getTime() - this.config.bufferTimeMs);
+        return now < expirationWithBuffer;
+    }
+    /**
+     * Clean expired entries from cache
+     */
+    cleanExpiredEntries() {
+        const now = new Date();
+        let cleanedCount = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now >= entry.expiration) {
+                this.cache.delete(key);
+                cleanedCount++;
+            }
+        }
+        if (cleanedCount > 0 && this.config.enableLogging) {
+            (0, debug_logger_1.debugInfo)('CACHE', `🧹 Cleaned ${cleanedCount} expired session signature entries`);
+        }
+    }
+    /**
+     * Enforce cache size limits
+     */
+    enforceCacheSize() {
+        if (this.cache.size <= this.config.maxEntries) {
+            return;
+        }
+        // Sort entries by creation time and remove oldest
+        const entries = Array.from(this.cache.entries())
+            .sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+        const toRemove = entries.slice(0, this.cache.size - this.config.maxEntries);
+        for (const [key] of toRemove) {
+            this.cache.delete(key);
+        }
+        if (this.config.enableLogging) {
+            (0, debug_logger_1.debugInfo)('CACHE', `📦 Removed ${toRemove.length} oldest cache entries to maintain size limit`);
+        }
+    }
+    /**
+     * Get cached session signatures if valid
+     */
+    get(pkpTokenId, litActionCid, signerAddress, network) {
+        this.cleanExpiredEntries();
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const entry = this.cache.get(cacheKey);
+        if (!entry) {
+            if (this.config.enableLogging) {
+                (0, debug_logger_1.debugLog)('CACHE', `❌ Session signatures cache miss: ${cacheKey}`);
+            }
+            return null;
+        }
+        if (!this.isEntryValid(entry)) {
+            this.cache.delete(cacheKey);
+            if (this.config.enableLogging) {
+                (0, debug_logger_1.debugWarn)('CACHE', `⏰ Session signatures expired: ${cacheKey}`);
+            }
+            return null;
+        }
+        if (this.config.enableLogging) {
+            const timeUntilExpiry = entry.expiration.getTime() - Date.now();
+            (0, debug_logger_1.debugInfo)('CACHE', `✅ Session signatures cache hit: ${cacheKey} (expires in ${Math.round(timeUntilExpiry / 1000)}s)`);
+        }
+        return entry.sessionSigs;
+    }
+    /**
+     * Cache session signatures
+     */
+    set(pkpTokenId, litActionCid, signerAddress, network, sessionSigs, expiration) {
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const entry = {
+            sessionSigs,
+            expiration,
+            pkpTokenId,
+            litActionCid,
+            signerAddress,
+            network,
+            createdAt: new Date()
+        };
+        this.cache.set(cacheKey, entry);
+        if (this.config.enableLogging) {
+            const timeUntilExpiry = expiration.getTime() - Date.now();
+            (0, debug_logger_1.debugInfo)('CACHE', `💾 Cached session signatures: ${cacheKey} (expires in ${Math.round(timeUntilExpiry / 1000)}s)`);
+        }
+        this.enforceCacheSize();
+    }
+    /**
+     * Clear all cached session signatures
+     */
+    clear() {
+        const size = this.cache.size;
+        this.cache.clear();
+        if (this.config.enableLogging) {
+            (0, debug_logger_1.debugInfo)('CACHE', `🗑️ Cleared ${size} cached session signature entries`);
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        this.cleanExpiredEntries();
+        return {
+            size: this.cache.size,
+            maxEntries: this.config.maxEntries,
+            utilizationPercent: Math.round((this.cache.size / this.config.maxEntries) * 100)
+        };
+    }
+    /**
+     * Remove specific cache entry
+     */
+    delete(pkpTokenId, litActionCid, signerAddress, network) {
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const deleted = this.cache.delete(cacheKey);
+        if (deleted && this.config.enableLogging) {
+            (0, debug_logger_1.debugInfo)('CACHE', `🗑️ Removed session signatures from cache: ${cacheKey}`);
+        }
+        return deleted;
+    }
+}
+// Global session signature cache instance
+exports.sessionSignatureCache = new SessionSignatureCache();
+/**
+ * Enhanced session signature generator with caching
+ */
+async function generateSessionSignaturesWithCache(litNodeClient, sessionConfig, pkpTokenId, litActionCid, signerAddress, network = 'datil') {
+    // Check cache first
+    const cached = exports.sessionSignatureCache.get(pkpTokenId, litActionCid, signerAddress, network);
+    if (cached) {
+        return cached;
+    }
+    // Generate new session signatures
+    (0, debug_logger_1.debugInfo)('CACHE', '🔐 Generating new session signatures (cache miss)...');
+    const sessionSigs = await litNodeClient.getSessionSigs(sessionConfig);
+    // Extract expiration from config
+    const expiration = new Date(sessionConfig.expiration);
+    // Cache the result
+    exports.sessionSignatureCache.set(pkpTokenId, litActionCid, signerAddress, network, sessionSigs, expiration);
+    const sigCount = Object.keys(sessionSigs).length;
+    (0, debug_logger_1.debugInfo)('CACHE', `✅ Generated and cached ${sigCount} session signatures`);
+    return sessionSigs;
+}
+/**
+ * Configure the global session signature cache
+ */
+function configureSessionSignatureCache(config) {
+    Object.assign(exports.sessionSignatureCache['config'], config);
+}
+/**
+ * Clear the global session signature cache
+ */
+function clearSessionSignatureCache() {
+    exports.sessionSignatureCache.clear();
+}
+/**
+ * Get session signature cache statistics
+ */
+function getSessionSignatureCacheStats() {
+    return exports.sessionSignatureCache.getStats();
+}
+//# sourceMappingURL=session-signature-cache.js.map