@gvnrdao/dh-sdk 0.0.291 → 0.0.293

package/dist/modules/cache/cache-manager.module.d.ts

@@ -1,236 +1,74 @@
 /**
- * Generic Cache Manager Module
+ * Cache Manager Module
  *
- * Provides a type-safe, generic LRU cache with TTL support.
- * Can be used for any data type (Bitcoin balances, addresses, query results, etc.)
- *
- * Features:
- * - Generic type support
- * - TTL-based expiration
- * - LRU eviction policy
- * - Hit/miss statistics
- * - Memory-efficient
- * - Thread-safe operations
- */
-import { Result } from '../../types/result';
-import { SDKError } from '../../utils/error-handler';
-/**
- * Cache entry with metadata
+ * Provides a simple cache factory for SDK modules.
+ * Each cache is an independent LRU cache with TTL support.
  */
-interface CacheEntry<T> {
-    /** Cached value */
-    value: T;
-    /** Unix timestamp when entry was created (ms) */
-    timestamp: number;
-    /** Number of times this entry was accessed */
-    hits: number;
-    /** Unix timestamp of last access (ms) */
-    lastAccessed: number;
+export interface CacheConfig {
+    maxSize: number;
+    ttlMs: number;
 }
-/**
- * Cache statistics
- */
 export interface CacheStats {
-    /** Current number of entries in cache */
     size: number;
-    /** Total cache hits */
-    hits: number;
-    /** Total cache misses */
-    misses: number;
-    /** Total evictions performed */
-    evictions: number;
-    /** Timestamp of oldest entry (ms) */
-    oldestEntry: number;
-    /** Timestamp of newest entry (ms) */
-    newestEntry: number;
-    /** Hit rate as percentage (0-100) */
-    hitRate: number;
+    maxSize: number;
+    ttlMs: number;
 }
 /**
- * Cache configuration
- */
-export interface CacheConfig {
-    /** Maximum number of entries (default: 1000) */
-    maxSize?: number;
-    /** Time-to-live in milliseconds (default: 60000 = 1 minute) */
-    ttlMs?: number;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-    /** Cache name for logging (default: 'Cache') */
-    name?: string;
-}
-/**
- * Generic LRU Cache with TTL support
- *
- * @template K - Key type (usually string)
- * @template V - Value type
- *
- * @example
- * ```typescript
- * // Create a cache for Bitcoin balances
- * const balanceCache = new LRUCache<string, BitcoinBalance>({
- *   maxSize: 500,
- *   ttlMs: 60000,
- *   name: 'BitcoinBalance'
- * });
- *
- * // Set value
- * balanceCache.set('bc1q...', { balance: Satoshis(50000000n) });
- *
- * // Get value
- * const balance = balanceCache.get('bc1q...');
- * if (balance) {
- *   console.log('Cached balance:', balance.balance);
- * }
- * ```
+ * Simple LRU Cache with TTL support
  */
-export declare class LRUCache<K, V> {
+export declare class Cache<T = any> {
     private cache;
-    /**
-     * Audit M-J: singleflight registry for `getOrCompute` / `getOrComputeResult`.
-     * Concurrent cache-miss callers for the same key share one inflight promise
-     * instead of each running `compute()` independently — important when the
-     * compute spends a paid LIT capacity credit or hits a rate-limited upstream.
-     */
-    private inflight;
-    private inflightResult;
     private readonly maxSize;
     private readonly ttlMs;
-    private readonly debug;
-    private readonly name;
-    private stats;
-    constructor(config?: CacheConfig);
+    constructor(config: CacheConfig);
     /**
      * Get value from cache
-     *
-     * Returns null if:
-     * - Key not found
-     * - Entry has expired
-     *
-     * @param key - Cache key
-     * @returns Cached value or null
      */
-    get(key: K): V | null;
-    /**
-     * Get value from cache with Result wrapper
-     *
-     * Useful when you want to distinguish between "not found" and "expired"
-     */
-    getResult(key: K): Result<V, SDKError>;
+    get(key: string): T | undefined;
     /**
      * Set value in cache
-     *
-     * If cache is full, evicts the least recently used entry
-     *
-     * @param key - Cache key
-     * @param value - Value to cache
-     * @param ttl - Optional custom TTL for this entry (ms)
-     */
-    set(key: K, value: V, ttl?: number): void;
-    /**
-     * Set value in cache with Result wrapper
      */
-    setResult(key: K, value: V, ttl?: number): Result<void, SDKError>;
+    set(key: string, value: T, ttl?: number): void;
     /**
-     * Check if key exists in cache (without affecting stats)
+     * Check if key exists in cache
      */
-    has(key: K): boolean;
+    has(key: string): boolean;
     /**
-     * Delete specific key from cache
+     * Delete key from cache
      */
-    delete(key: K): boolean;
+    delete(key: string): boolean;
     /**
-     * Clear entire cache
+     * Clear all cache entries
      */
     clear(): void;
     /**
-     * Get current cache size
-     */
-    size(): number;
-    /**
-     * Get cache statistics
-     */
-    getStats(): CacheStats;
-    /**
-     * Get hit rate percentage
-     */
-    getHitRate(): number;
-    /**
-     * Get all cached keys (for debugging)
-     */
-    getKeys(): K[];
-    /**
-     * Get all cached values (for debugging)
-     */
-    getValues(): V[];
-    /**
-     * Get all cache entries with metadata (for debugging)
-     */
-    getEntries(): Array<{
-        key: K;
-        value: V;
-        metadata: Omit<CacheEntry<V>, 'value'>;
-    }>;
-    /**
-     * Clean up expired entries
-     *
-     * Useful for periodic maintenance
-     *
-     * @returns Number of entries cleaned
+     * Clean expired entries
      */
     cleanExpired(): number;
     /**
-     * Check if cache entry is expired
-     */
-    private isExpired;
-    /**
-     * Evict least recently used entry
-     */
-    private evictLRU;
-    /**
-     * Get or compute value
-     *
-     * If key exists in cache, returns cached value.
-     * Otherwise, computes value using provided function and caches it.
-     *
-     * @param key - Cache key
-     * @param compute - Function to compute value if not in cache
-     * @param ttl - Optional custom TTL for this entry
-     * @returns Cached or computed value
-     */
-    getOrCompute(key: K, compute: () => Promise<V>, ttl?: number): Promise<V>;
-    /**
-     * Get or compute value with Result wrapper
+     * Get cache statistics
      */
-    getOrComputeResult(key: K, compute: () => Promise<Result<V, SDKError>>, ttl?: number): Promise<Result<V, SDKError>>;
-}
-/**
- * Generic cache interface for type safety
- */
-export interface Cache<T> {
-    get(key: string): T | null | undefined;
-    set(key: string, value: T): void;
-    delete(key: string): boolean;
-    clear(): void;
-    has(key: string): boolean;
-    size(): number;
-    getStats(): CacheStats;
+    getStats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    };
 }
 /**
- * Cache Manager - Factory for creating specialized caches
+ * Cache Manager
+ *
+ * Factory for creating named caches with specific configurations
  */
 export declare class CacheManager {
     private caches;
-    private readonly globalConfig;
-    constructor(globalConfig?: CacheConfig);
+    private readonly debug;
+    constructor(config?: {
+        debug?: boolean;
+    });
     /**
-     * Create or get a named cache
-     *
-     * @param name - Unique cache name
-     * @param config - Optional cache-specific configuration
-     * @returns LRU cache instance
+     * Get or create a cache instance
      */
-    getCache<K, V>(name: string, config?: CacheConfig): LRUCache<K, V>;
+    getCache<K extends string = string, V = any>(name: K, config: CacheConfig): Cache<V>;
     /**
      * Clear all caches
      */
@@ -242,18 +80,13 @@ export declare class CacheManager {
     /**
      * Get statistics for all caches
      */
-    getAllStats(): Record<string, CacheStats>;
-    /**
-     * Get list of all cache names
-     */
-    getCacheNames(): string[];
+    getAllStats(): Record<string, ReturnType<Cache["getStats"]>>;
     /**
-     * Delete a named cache
+     * Destroy cache manager
      */
-    deleteCache(name: string): boolean;
+    destroy(): void;
 }
-/**
- * Factory function to create a CacheManager instance
- */
-export declare function createCacheManager(config?: CacheConfig): CacheManager;
-export {};
+export { Cache as LRUCache };
+export declare function createCacheManager(config?: {
+    debug?: boolean;
+}): CacheManager;

package/dist/modules/diamond-hands-sdk.d.ts

@@ -847,7 +847,11 @@ export declare class DiamondHandsSDK {
     /**
      * Get cache statistics
      */
-    getCacheStats(): Record<string, import("./cache/cache-manager.module").CacheStats>;
+    getCacheStats(): Record<string, {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    }>;
     /**
      * Get contract manager (for advanced usage)
      */

package/dist/modules/loan/loan-query.module.d.ts

@@ -196,7 +196,11 @@ export declare class LoanQuery {
     /**
      * Get cache statistics
      */
-    getCacheStats(): import("../cache/cache-manager.module").CacheStats | null;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    } | null;
 }
 /**
  * Factory function to create a LoanQuery instance

package/dist/modules/pkp/pkp-manager.module.d.ts

@@ -128,7 +128,11 @@ export declare class PKPManager {
     /**
      * Get cache statistics
      */
-    getCacheStats(): import("../cache/cache-manager.module").CacheStats | null;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    } | null;
 }
 /**
  * Factory function to create a PKPManager instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gvnrdao/dh-sdk",
-  "version": "0.0.291",
+  "version": "0.0.293",
   "description": "TypeScript SDK for Diamond Hands Protocol - Bitcoin-backed lending with LIT Protocol PKPs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",