@zendfi/sdk 0.8.4 → 1.0.1

package/dist/chunk-5O5NAX65.mjs

@@ -1,366 +0,0 @@
-// src/helpers/cache.ts
-var SessionKeyCache = class {
-  memoryCache = /* @__PURE__ */ new Map();
-  config;
-  refreshTimers = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.config = {
-      storage: config.storage || "memory",
-      ttl: config.ttl || 30 * 60 * 1e3,
-      // 30 minutes default
-      autoRefresh: config.autoRefresh || false,
-      namespace: config.namespace || "zendfi_cache",
-      debug: config.debug || false
-    };
-  }
-  /**
-   * Get cached keypair or decrypt and cache
-   */
-  async getCached(sessionKeyId, decryptFn, options) {
-    this.log(`getCached: ${sessionKeyId}`);
-    const memoryCached = this.memoryCache.get(sessionKeyId);
-    if (memoryCached && Date.now() < memoryCached.expiry) {
-      this.log(`Memory cache HIT: ${sessionKeyId}`);
-      return memoryCached.keypair;
-    }
-    if (this.config.storage !== "memory") {
-      const persistentCached = await this.getFromStorage(sessionKeyId);
-      if (persistentCached && Date.now() < persistentCached.expiry) {
-        if (options?.deviceFingerprint && persistentCached.deviceFingerprint) {
-          if (options.deviceFingerprint !== persistentCached.deviceFingerprint) {
-            this.log(`Device fingerprint mismatch for ${sessionKeyId}`);
-            await this.invalidate(sessionKeyId);
-            return await this.decryptAndCache(sessionKeyId, decryptFn, options);
-          }
-        }
-        this.log(`Persistent cache HIT: ${sessionKeyId}`);
-        this.memoryCache.set(sessionKeyId, persistentCached);
-        return persistentCached.keypair;
-      }
-    }
-    this.log(`Cache MISS: ${sessionKeyId}`);
-    return await this.decryptAndCache(sessionKeyId, decryptFn, options);
-  }
-  /**
-   * Decrypt keypair and cache it
-   */
-  async decryptAndCache(sessionKeyId, decryptFn, options) {
-    const keypair = await decryptFn();
-    const expiry = Date.now() + this.config.ttl;
-    const cached = {
-      keypair,
-      expiry,
-      sessionKeyId,
-      deviceFingerprint: options?.deviceFingerprint
-    };
-    this.memoryCache.set(sessionKeyId, cached);
-    if (this.config.storage !== "memory") {
-      await this.setInStorage(sessionKeyId, cached);
-    }
-    if (this.config.autoRefresh) {
-      this.setupAutoRefresh(sessionKeyId, decryptFn, options);
-    }
-    this.log(`Cached: ${sessionKeyId}, expires in ${this.config.ttl}ms`);
-    return keypair;
-  }
-  /**
-   * Invalidate cached keypair
-   */
-  async invalidate(sessionKeyId) {
-    this.log(`Invalidating: ${sessionKeyId}`);
-    this.memoryCache.delete(sessionKeyId);
-    const timer = this.refreshTimers.get(sessionKeyId);
-    if (timer) {
-      clearTimeout(timer);
-      this.refreshTimers.delete(sessionKeyId);
-    }
-    if (this.config.storage !== "memory") {
-      await this.removeFromStorage(sessionKeyId);
-    }
-  }
-  /**
-   * Clear all cached keypairs
-   */
-  async clear() {
-    this.log("Clearing all cache");
-    this.memoryCache.clear();
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.refreshTimers.clear();
-    if (this.config.storage !== "memory") {
-      await this.clearStorage();
-    }
-  }
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    const entries = Array.from(this.memoryCache.entries()).map(([id, cached]) => ({
-      sessionKeyId: id,
-      expiresIn: Math.max(0, cached.expiry - Date.now())
-    }));
-    return { size: this.memoryCache.size, entries };
-  }
-  /**
-   * Check if a session key is cached and valid
-   */
-  isCached(sessionKeyId) {
-    const cached = this.memoryCache.get(sessionKeyId);
-    return cached ? Date.now() < cached.expiry : false;
-  }
-  /**
-   * Update TTL for a cached session key
-   */
-  async extendTTL(sessionKeyId, additionalMs) {
-    const cached = this.memoryCache.get(sessionKeyId);
-    if (!cached) return false;
-    cached.expiry += additionalMs;
-    this.memoryCache.set(sessionKeyId, cached);
-    if (this.config.storage !== "memory") {
-      await this.setInStorage(sessionKeyId, cached);
-    }
-    this.log(`Extended TTL for ${sessionKeyId} by ${additionalMs}ms`);
-    return true;
-  }
-  // ============================================
-  // Storage Backend Implementations
-  // ============================================
-  async getFromStorage(sessionKeyId) {
-    try {
-      const key = this.getStorageKey(sessionKeyId);
-      if (this.config.storage === "localStorage") {
-        const data = localStorage.getItem(key);
-        if (!data) return null;
-        const parsed = JSON.parse(data);
-        return {
-          ...parsed,
-          keypair: this.deserializeKeypair(parsed.keypair)
-        };
-      }
-      if (this.config.storage === "indexedDB") {
-        return await this.getFromIndexedDB(key);
-      }
-      if (typeof this.config.storage === "object") {
-        const data = await this.config.storage.get(key);
-        if (!data) return null;
-        const parsed = JSON.parse(data);
-        return {
-          ...parsed,
-          keypair: this.deserializeKeypair(parsed.keypair)
-        };
-      }
-    } catch (error) {
-      this.log(`Error reading from storage: ${error}`);
-    }
-    return null;
-  }
-  async setInStorage(sessionKeyId, cached) {
-    try {
-      const key = this.getStorageKey(sessionKeyId);
-      const serialized = {
-        ...cached,
-        keypair: this.serializeKeypair(cached.keypair)
-      };
-      if (this.config.storage === "localStorage") {
-        localStorage.setItem(key, JSON.stringify(serialized));
-        return;
-      }
-      if (this.config.storage === "indexedDB") {
-        await this.setInIndexedDB(key, serialized);
-        return;
-      }
-      if (typeof this.config.storage === "object") {
-        await this.config.storage.set(key, JSON.stringify(serialized));
-      }
-    } catch (error) {
-      this.log(`Error writing to storage: ${error}`);
-    }
-  }
-  async removeFromStorage(sessionKeyId) {
-    try {
-      const key = this.getStorageKey(sessionKeyId);
-      if (this.config.storage === "localStorage") {
-        localStorage.removeItem(key);
-        return;
-      }
-      if (this.config.storage === "indexedDB") {
-        await this.removeFromIndexedDB(key);
-        return;
-      }
-      if (typeof this.config.storage === "object") {
-        await this.config.storage.remove(key);
-      }
-    } catch (error) {
-      this.log(`Error removing from storage: ${error}`);
-    }
-  }
-  async clearStorage() {
-    try {
-      if (this.config.storage === "localStorage") {
-        const keysToRemove = [];
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
-          if (key?.startsWith(this.config.namespace)) {
-            keysToRemove.push(key);
-          }
-        }
-        keysToRemove.forEach((key) => localStorage.removeItem(key));
-        return;
-      }
-      if (this.config.storage === "indexedDB") {
-        await this.clearIndexedDB();
-        return;
-      }
-      if (typeof this.config.storage === "object") {
-        await this.config.storage.clear();
-      }
-    } catch (error) {
-      this.log(`Error clearing storage: ${error}`);
-    }
-  }
-  // ============================================
-  // IndexedDB Helpers
-  // ============================================
-  async getFromIndexedDB(key) {
-    return new Promise((resolve) => {
-      const request = indexedDB.open(this.config.namespace, 1);
-      request.onerror = () => resolve(null);
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        if (!db.objectStoreNames.contains("cache")) {
-          db.createObjectStore("cache");
-        }
-      };
-      request.onsuccess = (event) => {
-        const db = event.target.result;
-        const transaction = db.transaction(["cache"], "readonly");
-        const store = transaction.objectStore("cache");
-        const getRequest = store.get(key);
-        getRequest.onsuccess = () => {
-          resolve(getRequest.result || null);
-        };
-        getRequest.onerror = () => resolve(null);
-      };
-    });
-  }
-  async setInIndexedDB(key, value) {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.config.namespace, 1);
-      request.onerror = () => reject(new Error("IndexedDB error"));
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        if (!db.objectStoreNames.contains("cache")) {
-          db.createObjectStore("cache");
-        }
-      };
-      request.onsuccess = (event) => {
-        const db = event.target.result;
-        const transaction = db.transaction(["cache"], "readwrite");
-        const store = transaction.objectStore("cache");
-        store.put(value, key);
-        transaction.oncomplete = () => resolve();
-        transaction.onerror = () => reject(new Error("IndexedDB transaction error"));
-      };
-    });
-  }
-  async removeFromIndexedDB(key) {
-    return new Promise((resolve) => {
-      const request = indexedDB.open(this.config.namespace, 1);
-      request.onsuccess = (event) => {
-        const db = event.target.result;
-        const transaction = db.transaction(["cache"], "readwrite");
-        const store = transaction.objectStore("cache");
-        store.delete(key);
-        transaction.oncomplete = () => resolve();
-      };
-      request.onerror = () => resolve();
-    });
-  }
-  async clearIndexedDB() {
-    return new Promise((resolve) => {
-      const request = indexedDB.open(this.config.namespace, 1);
-      request.onsuccess = (event) => {
-        const db = event.target.result;
-        const transaction = db.transaction(["cache"], "readwrite");
-        const store = transaction.objectStore("cache");
-        store.clear();
-        transaction.oncomplete = () => resolve();
-      };
-      request.onerror = () => resolve();
-    });
-  }
-  // ============================================
-  // Serialization
-  // ============================================
-  serializeKeypair(keypair) {
-    if (keypair && typeof keypair === "object" && "secretKey" in keypair) {
-      return {
-        type: "solana",
-        secretKey: Array.from(keypair.secretKey)
-      };
-    }
-    if (keypair instanceof Uint8Array) {
-      return {
-        type: "uint8array",
-        data: Array.from(keypair)
-      };
-    }
-    return keypair;
-  }
-  deserializeKeypair(data) {
-    if (!data || typeof data !== "object") return data;
-    if (data.type === "solana" && data.secretKey) {
-      return new Uint8Array(data.secretKey);
-    }
-    if (data.type === "uint8array" && data.data) {
-      return new Uint8Array(data.data);
-    }
-    return data;
-  }
-  // ============================================
-  // Auto-Refresh
-  // ============================================
-  setupAutoRefresh(sessionKeyId, decryptFn, options) {
-    const existingTimer = this.refreshTimers.get(sessionKeyId);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-    const refreshIn = Math.max(0, this.config.ttl - 5 * 60 * 1e3);
-    const timer = setTimeout(async () => {
-      this.log(`Auto-refreshing: ${sessionKeyId}`);
-      try {
-        await this.decryptAndCache(sessionKeyId, decryptFn, options);
-      } catch (error) {
-        this.log(`Auto-refresh failed: ${error}`);
-      }
-    }, refreshIn);
-    this.refreshTimers.set(sessionKeyId, timer);
-  }
-  // ============================================
-  // Utilities
-  // ============================================
-  getStorageKey(sessionKeyId) {
-    return `${this.config.namespace}:${sessionKeyId}`;
-  }
-  log(message) {
-    if (this.config.debug) {
-      console.log(`[SessionKeyCache] ${message}`);
-    }
-  }
-};
-var QuickCaches = {
-  /** Memory-only cache (30 minutes) */
-  memory: () => new SessionKeyCache({ storage: "memory", ttl: 30 * 60 * 1e3 }),
-  /** Persistent cache (1 hour, survives reload) */
-  persistent: () => new SessionKeyCache({ storage: "localStorage", ttl: 60 * 60 * 1e3 }),
-  /** Long-term cache (24 hours, IndexedDB) */
-  longTerm: () => new SessionKeyCache({ storage: "indexedDB", ttl: 24 * 60 * 60 * 1e3, autoRefresh: true }),
-  /** Secure cache (5 minutes, memory-only) */
-  secure: () => new SessionKeyCache({ storage: "memory", ttl: 5 * 60 * 1e3 })
-};
-
-export {
-  SessionKeyCache,
-  QuickCaches
-};