@gvnrdao/dh-sdk 0.0.291 → 0.0.293

package/dist/index.js

@@ -3744,7 +3744,7 @@ var require_abstract_coder = __commonJS({
     function toObject2(names2, items, deep) {
       if (names2.indexOf(null) >= 0) {
         return items.map((item, index) => {
-          if (item instanceof Result11) {
+          if (item instanceof Result10) {
             return toObject2(getNames2(item), item, deep);
           }
           return item;
@@ -3753,7 +3753,7 @@ var require_abstract_coder = __commonJS({
       return names2.reduce((accum, name, index) => {
         let item = items.getValue(name);
         if (!(name in accum)) {
-          if (deep && item instanceof Result11) {
+          if (deep && item instanceof Result10) {
             item = toObject2(getNames2(item), item, deep);
           }
           accum[name] = item;
@@ -3761,7 +3761,7 @@ var require_abstract_coder = __commonJS({
         return accum;
       }, {});
     }
-    var Result11 = class _Result extends Array {
+    var Result10 = class _Result extends Array {
       // No longer used; but cannot be removed as it will remove the
       // #private field from the .d.ts which may break backwards
       // compatibility
@@ -3965,7 +3965,7 @@ var require_abstract_coder = __commonJS({
         return new _Result(_guard5, items, keys);
       }
     };
-    exports2.Result = Result11;
+    exports2.Result = Result10;
     function checkResultErrors2(result) {
       const errors2 = [];
       const checkErrors = function(path2, object2) {
@@ -34943,8 +34943,8 @@ function getMainnetConfig() {
       bitcoinWithdrawalAddressRegistry: MAINNET_CONTRACTS.BitcoinWithdrawalAddressRegistry || ""
     },
     subgraphs: {
-      diamondHandsUrl: "https://gateway-arbitrum.network.thegraph.com/api/subgraphs/id/CCTPsdYqco2jChDLLBQTbdJWwoukVoMt1cXeR9ti6r9A"
-      // Published Sepolia subgraph on Arbitrum One
+      diamondHandsUrl: "https://api.studio.thegraph.com/query/1755201/diamond-hands/v1.0.0-mainnet"
+      // Mainnet subgraph (keyless studio endpoint, browser-queryable)
     },
     litNetwork: "chipotle",
     debug: false
@@ -90299,7 +90299,7 @@ __export(src_exports, {
   ErrorSeverity: () => ErrorSeverity,
   EventHelpers: () => EventHelpers,
   LOCALHOST_CONTRACTS: () => LOCALHOST_CONTRACTS,
-  LRUCache: () => LRUCache,
+  LRUCache: () => Cache,
   LoanCreator: () => LoanCreator,
   LoanQuery: () => LoanQuery,
   LoanStatus: () => LoanStatus,
@@ -109823,365 +109823,106 @@ function createContractManager(config) {
 }
 
 // src/modules/cache/cache-manager.module.ts
-var LRUCache = class {
-  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.
-   */
-  inflight = /* @__PURE__ */ new Map();
-  inflightResult = /* @__PURE__ */ new Map();
+var Cache = class {
+  cache = /* @__PURE__ */ new Map();
   maxSize;
   ttlMs;
-  debug;
-  name;
-  // Statistics
-  stats = {
-    hits: 0,
-    misses: 0,
-    evictions: 0
-  };
-  constructor(config = {}) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = config.maxSize || 1e3;
-    this.ttlMs = config.ttlMs || 6e4;
-    this.debug = config.debug || false;
-    this.name = config.name || "Cache";
-    if (this.debug) {
-      console.log(
-        `\u{1F4BE} [${this.name}] Initialized: maxSize=${this.maxSize}, ttl=${this.ttlMs}ms`
-      );
-    }
+  constructor(config) {
+    this.maxSize = config.maxSize;
+    this.ttlMs = config.ttlMs;
   }
   /**
    * Get value from cache
-   *
-   * Returns null if:
-   * - Key not found
-   * - Entry has expired
-   *
-   * @param key - Cache key
-   * @returns Cached value or null
    */
   get(key) {
     const entry = this.cache.get(key);
     if (!entry) {
-      this.stats.misses++;
-      if (this.debug) {
-        console.log(`\u274C [${this.name}] Cache MISS: ${String(key)}`);
-      }
-      return null;
+      return void 0;
     }
-    if (this.isExpired(entry)) {
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
       this.cache.delete(key);
-      this.stats.misses++;
-      if (this.debug) {
-        const age = Date.now() - entry.timestamp;
-        console.log(`\u23F0 [${this.name}] Cache EXPIRED: ${String(key)} (age: ${age}ms)`);
-      }
-      return null;
-    }
-    entry.hits++;
-    entry.lastAccessed = Date.now();
-    this.cache.set(key, entry);
-    this.stats.hits++;
-    if (this.debug) {
-      const age = Date.now() - entry.timestamp;
-      console.log(
-        `\u2705 [${this.name}] Cache HIT: ${String(key)} (age: ${age}ms, hits: ${entry.hits})`
-      );
+      return void 0;
     }
     return entry.value;
   }
-  /**
-   * Get value from cache with Result wrapper
-   *
-   * Useful when you want to distinguish between "not found" and "expired"
-   */
-  getResult(key) {
-    const value = this.get(key);
-    if (value === null) {
-      return failure(
-        new SDKError({
-          message: `Cache miss for key: ${String(key)}`,
-          category: "CACHE" /* CACHE */,
-          severity: "LOW" /* LOW */,
-          originalError: new Error("Cache miss")
-        })
-      );
-    }
-    return success(value);
-  }
   /**
    * 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, value, ttl) {
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-      this.evictLRU();
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
     }
-    const entry = {
+    this.cache.set(key, {
       value,
       timestamp: Date.now(),
-      hits: 0,
-      lastAccessed: Date.now()
-    };
-    this.cache.set(key, entry);
-    if (this.debug) {
-      const effectiveTtl = ttl || this.ttlMs;
-      console.log(
-        `\u{1F4BE} [${this.name}] Cache SET: ${String(key)} (ttl: ${effectiveTtl}ms, size: ${this.cache.size}/${this.maxSize})`
-      );
-    }
-  }
-  /**
-   * Set value in cache with Result wrapper
-   */
-  setResult(key, value, ttl) {
-    try {
-      this.set(key, value, ttl);
-      return success(void 0);
-    } catch (error2) {
-      return failure(
-        new SDKError({
-          message: `Failed to set cache value for key: ${String(key)}`,
-          category: "CACHE" /* CACHE */,
-          severity: "MEDIUM" /* MEDIUM */,
-          originalError: error2 instanceof Error ? error2 : new Error(String(error2))
-        })
-      );
-    }
+      ttl: ttl || this.ttlMs
+    });
   }
   /**
-   * Check if key exists in cache (without affecting stats)
+   * Check if key exists in cache
    */
   has(key) {
-    const entry = this.cache.get(key);
-    return entry !== void 0 && !this.isExpired(entry);
+    return this.get(key) !== void 0;
   }
   /**
-   * Delete specific key from cache
+   * Delete key from cache
    */
   delete(key) {
-    const deleted = this.cache.delete(key);
-    if (deleted && this.debug) {
-      console.log(`\u{1F5D1}\uFE0F  [${this.name}] Cache DELETE: ${String(key)}`);
-    }
-    return deleted;
+    return this.cache.delete(key);
   }
   /**
-   * Clear entire cache
+   * Clear all cache entries
    */
   clear() {
-    const previousSize = this.cache.size;
     this.cache.clear();
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      evictions: 0
-    };
-    if (this.debug) {
-      console.log(`\u{1F9F9} [${this.name}] Cache CLEARED: removed ${previousSize} entries`);
-    }
-  }
-  /**
-   * Get current cache size
-   */
-  size() {
-    return this.cache.size;
-  }
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    const entries = Array.from(this.cache.values());
-    const timestamps = entries.map((e) => e.timestamp);
-    const total = this.stats.hits + this.stats.misses;
-    const hitRate = total === 0 ? 0 : this.stats.hits / total * 100;
-    return {
-      size: this.cache.size,
-      hits: this.stats.hits,
-      misses: this.stats.misses,
-      evictions: this.stats.evictions,
-      oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : 0,
-      newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : 0,
-      hitRate
-    };
   }
   /**
-   * Get hit rate percentage
-   */
-  getHitRate() {
-    const total = this.stats.hits + this.stats.misses;
-    return total === 0 ? 0 : this.stats.hits / total * 100;
-  }
-  /**
-   * Get all cached keys (for debugging)
-   */
-  getKeys() {
-    return Array.from(this.cache.keys());
-  }
-  /**
-   * Get all cached values (for debugging)
-   */
-  getValues() {
-    return Array.from(this.cache.values()).map((entry) => entry.value);
-  }
-  /**
-   * Get all cache entries with metadata (for debugging)
-   */
-  getEntries() {
-    return Array.from(this.cache.entries()).map(([key, entry]) => ({
-      key,
-      value: entry.value,
-      metadata: {
-        timestamp: entry.timestamp,
-        hits: entry.hits,
-        lastAccessed: entry.lastAccessed
-      }
-    }));
-  }
-  /**
-   * Clean up expired entries
-   *
-   * Useful for periodic maintenance
-   *
-   * @returns Number of entries cleaned
+   * Clean expired entries
    */
   cleanExpired() {
     const now = Date.now();
-    let cleanedCount = 0;
+    let cleaned = 0;
     for (const [key, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > this.ttlMs) {
+      if (now - entry.timestamp > entry.ttl) {
         this.cache.delete(key);
-        cleanedCount++;
-      }
-    }
-    if (cleanedCount > 0 && this.debug) {
-      console.log(`\u{1F9F9} [${this.name}] Cleaned ${cleanedCount} expired entries`);
-    }
-    return cleanedCount;
-  }
-  /**
-   * Check if cache entry is expired
-   */
-  isExpired(entry) {
-    return Date.now() - entry.timestamp > this.ttlMs;
-  }
-  /**
-   * Evict least recently used entry
-   */
-  evictLRU() {
-    let oldestKey = null;
-    let oldestAccess = Infinity;
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.lastAccessed < oldestAccess) {
-        oldestAccess = entry.lastAccessed;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey !== null) {
-      this.cache.delete(oldestKey);
-      this.stats.evictions++;
-      if (this.debug) {
-        const timeSinceAccess = Date.now() - oldestAccess;
-        console.log(
-          `\u267B\uFE0F  [${this.name}] Cache EVICT (LRU): ${String(oldestKey)} (last accessed: ${timeSinceAccess}ms ago)`
-        );
+        cleaned++;
       }
     }
+    return cleaned;
   }
   /**
-   * 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
-   */
-  async getOrCompute(key, compute, ttl) {
-    const cached = this.get(key);
-    if (cached !== null) {
-      return cached;
-    }
-    const existing = this.inflight.get(key);
-    if (existing) {
-      return existing;
-    }
-    const computePromise = (async () => {
-      try {
-        const value = await compute();
-        this.set(key, value, ttl);
-        return value;
-      } finally {
-        this.inflight.delete(key);
-      }
-    })();
-    this.inflight.set(key, computePromise);
-    return computePromise;
-  }
-  /**
-   * Get or compute value with Result wrapper
+   * Get cache statistics
    */
-  async getOrComputeResult(key, compute, ttl) {
-    const cached = this.get(key);
-    if (cached !== null) {
-      return success(cached);
-    }
-    const existing = this.inflightResult.get(key);
-    if (existing) {
-      return existing;
-    }
-    const computePromise = (async () => {
-      try {
-        return await compute();
-      } finally {
-        this.inflightResult.delete(key);
-      }
-    })();
-    this.inflightResult.set(key, computePromise);
-    const result = await computePromise;
-    if (result.success) {
-      this.set(key, result.value, ttl);
-    }
-    return result;
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      ttlMs: this.ttlMs
+    };
   }
 };
 var CacheManager = class {
   caches = /* @__PURE__ */ new Map();
-  globalConfig;
-  constructor(globalConfig = {}) {
-    this.globalConfig = globalConfig;
+  debug;
+  constructor(config = {}) {
+    this.debug = config.debug || false;
   }
   /**
-   * 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(name, config) {
-    const existingCache = this.caches.get(name);
-    if (existingCache) {
-      return existingCache;
+    if (this.caches.has(name)) {
+      return this.caches.get(name);
     }
-    const mergedConfig = {
-      ...this.globalConfig,
-      ...config,
-      name
-    };
-    const cache = new LRUCache(mergedConfig);
+    const cache = new Cache(config);
     this.caches.set(name, cache);
+    if (this.debug) {
+      console.log(`[CacheManager] Created cache: ${name}`, config);
+    }
     return cache;
   }
   /**
@@ -110196,11 +109937,11 @@ var CacheManager = class {
    * Clean expired entries from all caches
    */
   cleanAllExpired() {
-    let totalCleaned = 0;
+    let total = 0;
     for (const cache of this.caches.values()) {
-      totalCleaned += cache.cleanExpired();
+      total += cache.cleanExpired();
     }
-    return totalCleaned;
+    return total;
   }
   /**
    * Get statistics for all caches
@@ -110213,16 +109954,11 @@ var CacheManager = class {
     return stats;
   }
   /**
-   * Get list of all cache names
+   * Destroy cache manager
    */
-  getCacheNames() {
-    return Array.from(this.caches.keys());
-  }
-  /**
-   * Delete a named cache
-   */
-  deleteCache(name) {
-    return this.caches.delete(name);
+  destroy() {
+    this.clearAll();
+    this.caches.clear();
   }
 };
 function createCacheManager(config) {