@unicitylabs/sphere-sdk 0.4.2 → 0.4.4

package/dist/impl/browser/index.cjs

@@ -414,6 +414,7 @@ function createLocalStorageProvider(config) {
 var DB_NAME = "sphere-storage";
 var DB_VERSION = 1;
 var STORE_NAME = "kv";
+var connectionSeq = 0;
 var IndexedDBStorageProvider = class {
   id = "indexeddb-storage";
   name = "IndexedDB Storage";
@@ -425,6 +426,8 @@ var IndexedDBStorageProvider = class {
   identity = null;
   status = "disconnected";
   db = null;
+  /** Monotonic connection ID for tracing open/close pairs */
+  connId = 0;
   constructor(config) {
     this.prefix = config?.prefix ?? "sphere_";
     this.dbName = config?.dbName ?? DB_NAME;
@@ -435,24 +438,35 @@ var IndexedDBStorageProvider = class {
   // ===========================================================================
   async connect() {
     if (this.status === "connected" && this.db) return;
-    this.status = "connecting";
-    console.log(`[IndexedDBStorage] connect: opening db=${this.dbName}`);
-    try {
-      this.db = await Promise.race([
-        this.openDatabase(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("IndexedDB open timed out after 5s")), 5e3)
-        )
-      ]);
-      this.status = "connected";
-      console.log(`[IndexedDBStorage] connect: connected to db=${this.dbName}`);
-    } catch (error) {
-      this.status = "error";
-      throw new Error(`IndexedDB not available: ${error}`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      this.status = "connecting";
+      const t0 = Date.now();
+      console.log(`[IndexedDBStorage] connect: opening db=${this.dbName}, attempt=${attempt + 1}/2`);
+      try {
+        this.db = await Promise.race([
+          this.openDatabase(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("IndexedDB open timed out after 5s")), 5e3)
+          )
+        ]);
+        this.status = "connected";
+        console.log(`[IndexedDBStorage] connect: connected db=${this.dbName} connId=${this.connId} (${Date.now() - t0}ms)`);
+        return;
+      } catch (error) {
+        console.warn(`[IndexedDBStorage] connect: open failed db=${this.dbName} attempt=${attempt + 1} (${Date.now() - t0}ms):`, error);
+        if (attempt === 0) {
+          this.status = "disconnected";
+          await new Promise((r) => setTimeout(r, 1e3));
+          continue;
+        }
+        this.status = "error";
+        throw new Error(`IndexedDB not available: ${error}`);
+      }
     }
   }
   async disconnect() {
-    console.log(`[IndexedDBStorage] disconnect: closing db=${this.dbName}, wasConnected=${!!this.db}`);
+    const cid = this.connId;
+    console.log(`[IndexedDBStorage] disconnect: db=${this.dbName} connId=${cid} wasConnected=${!!this.db}`);
     if (this.db) {
       this.db.close();
       this.db = null;
@@ -509,32 +523,36 @@ var IndexedDBStorageProvider = class {
   }
   async clear(prefix) {
     if (!prefix) {
-      console.log(`[IndexedDBStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
-      if (this.db) {
-        this.db.close();
-        this.db = null;
-      }
-      this.status = "disconnected";
-      await new Promise((resolve) => {
-        try {
-          const req = indexedDB.deleteDatabase(this.dbName);
-          req.onsuccess = () => {
-            console.log(`[IndexedDBStorage] clear: deleted db=${this.dbName}`);
-            resolve();
-          };
-          req.onerror = () => {
-            console.warn(`[IndexedDBStorage] clear: error deleting db=${this.dbName}`, req.error);
-            resolve();
-          };
-          req.onblocked = () => {
-            console.warn(`[IndexedDBStorage] clear: deleteDatabase blocked for db=${this.dbName}`);
-            resolve();
-          };
-        } catch {
-          resolve();
+      const t0 = Date.now();
+      const prevConnId = this.connId;
+      console.log(`[IndexedDBStorage] clear: starting db=${this.dbName} connId=${prevConnId} status=${this.status} hasDb=${!!this.db}`);
+      try {
+        if (!this.db || this.status !== "connected") {
+          if (this.db) {
+            console.log(`[IndexedDBStorage] clear: closing stale handle connId=${prevConnId}`);
+            this.db.close();
+            this.db = null;
+          }
+          console.log(`[IndexedDBStorage] clear: opening fresh connection for wipe`);
+          this.db = await Promise.race([
+            this.openDatabase(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("open timed out")), 3e3)
+            )
+          ]);
+          this.status = "connected";
         }
-      });
-      this.log("Database deleted:", this.dbName);
+        await this.idbClear();
+        console.log(`[IndexedDBStorage] clear: store cleared db=${this.dbName} connId=${this.connId} (${Date.now() - t0}ms)`);
+      } catch (err) {
+        console.warn(`[IndexedDBStorage] clear: failed db=${this.dbName} (${Date.now() - t0}ms)`, err);
+      } finally {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+        }
+        this.status = "disconnected";
+      }
       return;
     }
     this.ensureConnected();
@@ -600,9 +618,22 @@ var IndexedDBStorageProvider = class {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(this.dbName, DB_VERSION);
       request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(request.result);
+      request.onsuccess = () => {
+        const db = request.result;
+        const cid = ++connectionSeq;
+        this.connId = cid;
+        db.onversionchange = () => {
+          console.log(`[IndexedDBStorage] onversionchange: auto-closing db=${this.dbName} connId=${cid}`);
+          db.close();
+          if (this.db === db) {
+            this.db = null;
+            this.status = "disconnected";
+          }
+        };
+        resolve(db);
+      };
       request.onblocked = () => {
-        console.warn("[IndexedDBStorageProvider] open blocked by another connection");
+        console.warn(`[IndexedDBStorage] open blocked by another connection, db=${this.dbName}`);
       };
       request.onupgradeneeded = (event) => {
         const db = event.target.result;
@@ -681,18 +712,23 @@ var DB_NAME2 = "sphere-token-storage";
 var DB_VERSION2 = 1;
 var STORE_TOKENS = "tokens";
 var STORE_META = "meta";
+var connectionSeq2 = 0;
 var IndexedDBTokenStorageProvider = class {
   id = "indexeddb-token-storage";
   name = "IndexedDB Token Storage";
   type = "local";
   dbNamePrefix;
   dbName;
+  debug;
   db = null;
   status = "disconnected";
   identity = null;
+  /** Monotonic connection ID for tracing open/close pairs */
+  connId = 0;
   constructor(config) {
     this.dbNamePrefix = config?.dbNamePrefix ?? DB_NAME2;
     this.dbName = this.dbNamePrefix;
+    this.debug = config?.debug ?? false;
   }
   setIdentity(identity) {
     this.identity = identity;
@@ -700,28 +736,31 @@ var IndexedDBTokenStorageProvider = class {
       const addressId = getAddressId(identity.directAddress);
       this.dbName = `${this.dbNamePrefix}-${addressId}`;
     }
-    console.log(`[IndexedDBTokenStorage] setIdentity \u2192 db=${this.dbName}`);
+    console.log(`[IndexedDBTokenStorage] setIdentity: db=${this.dbName}`);
   }
   async initialize() {
+    const prevConnId = this.connId;
+    const t0 = Date.now();
     try {
       if (this.db) {
-        console.log(`[IndexedDBTokenStorage] initialize: closing existing connection before re-open (db=${this.dbName})`);
+        console.log(`[IndexedDBTokenStorage] initialize: closing existing connId=${prevConnId} before re-open (db=${this.dbName})`);
         this.db.close();
         this.db = null;
       }
       console.log(`[IndexedDBTokenStorage] initialize: opening db=${this.dbName}`);
       this.db = await this.openDatabase();
       this.status = "connected";
-      console.log(`[IndexedDBTokenStorage] initialize: connected to db=${this.dbName}`);
+      console.log(`[IndexedDBTokenStorage] initialize: connected db=${this.dbName} connId=${this.connId} (${Date.now() - t0}ms)`);
       return true;
     } catch (error) {
-      console.error("[IndexedDBTokenStorage] Failed to initialize:", error);
+      console.error(`[IndexedDBTokenStorage] initialize: failed db=${this.dbName} (${Date.now() - t0}ms):`, error);
       this.status = "error";
       return false;
     }
   }
   async shutdown() {
-    console.log(`[IndexedDBTokenStorage] shutdown: closing db=${this.dbName}, wasConnected=${!!this.db}`);
+    const cid = this.connId;
+    console.log(`[IndexedDBTokenStorage] shutdown: db=${this.dbName} connId=${cid} wasConnected=${!!this.db}`);
     if (this.db) {
       this.db.close();
       this.db = null;
@@ -879,56 +918,32 @@ var IndexedDBTokenStorageProvider = class {
     return meta !== null;
   }
   async clear() {
+    const t0 = Date.now();
     try {
-      console.log(`[IndexedDBTokenStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
       if (this.db) {
         this.db.close();
         this.db = null;
       }
       this.status = "disconnected";
-      const dbNames = [this.dbName];
-      if (typeof indexedDB.databases === "function") {
-        try {
-          const dbs = await Promise.race([
-            indexedDB.databases(),
-            new Promise(
-              (_, reject) => setTimeout(() => reject(new Error("timeout")), 1500)
-            )
-          ]);
-          for (const dbInfo of dbs) {
-            if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
-              dbNames.push(dbInfo.name);
-            }
-          }
-        } catch {
-        }
+      const dbNames = /* @__PURE__ */ new Set([this.dbName]);
+      for (const name of await this.findPrefixedDatabases()) {
+        dbNames.add(name);
       }
-      console.log(`[IndexedDBTokenStorage] clear: deleting ${dbNames.length} database(s):`, dbNames);
-      await Promise.all(dbNames.map(
-        (name) => new Promise((resolve) => {
-          try {
-            const req = indexedDB.deleteDatabase(name);
-            req.onsuccess = () => {
-              console.log(`[IndexedDBTokenStorage] clear: deleted db=${name}`);
-              resolve();
-            };
-            req.onerror = () => {
-              console.warn(`[IndexedDBTokenStorage] clear: error deleting db=${name}`, req.error);
-              resolve();
-            };
-            req.onblocked = () => {
-              console.warn(`[IndexedDBTokenStorage] clear: deleteDatabase blocked for db=${name}`);
-              resolve();
-            };
-          } catch {
-            resolve();
-          }
-        })
-      ));
-      console.log(`[IndexedDBTokenStorage] clear: done`);
-      return true;
+      console.log(`[IndexedDBTokenStorage] clear: clearing ${dbNames.size} database(s) (${[...dbNames].join(", ")})`);
+      const results = await Promise.allSettled(
+        [...dbNames].map((name) => this.clearDatabaseStores(name))
+      );
+      const failed = results.filter((r) => r.status === "rejected");
+      if (failed.length > 0) {
+        console.warn(
+          `[IndexedDBTokenStorage] clear: ${failed.length}/${dbNames.size} failed (${Date.now() - t0}ms)`,
+          failed.map((r) => r.reason)
+        );
+      }
+      console.log(`[IndexedDBTokenStorage] clear: done ${dbNames.size} database(s) (${Date.now() - t0}ms)`);
+      return failed.length === 0;
     } catch (err) {
-      console.warn("[IndexedDBTokenStorage] clear() failed:", err);
+      console.warn(`[IndexedDBTokenStorage] clear: failed (${Date.now() - t0}ms)`, err);
       return false;
     }
   }
@@ -938,11 +953,23 @@ var IndexedDBTokenStorageProvider = class {
   openDatabase() {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(this.dbName, DB_VERSION2);
-      request.onerror = () => {
-        reject(request.error);
-      };
+      request.onerror = () => reject(request.error);
       request.onsuccess = () => {
-        resolve(request.result);
+        const db = request.result;
+        const cid = ++connectionSeq2;
+        this.connId = cid;
+        db.onversionchange = () => {
+          console.log(`[IndexedDBTokenStorage] onversionchange: auto-closing db=${this.dbName} connId=${cid}`);
+          db.close();
+          if (this.db === db) {
+            this.db = null;
+            this.status = "disconnected";
+          }
+        };
+        resolve(db);
+      };
+      request.onblocked = () => {
+        console.warn(`[IndexedDBTokenStorage] open blocked by another connection, db=${this.dbName}`);
       };
       request.onupgradeneeded = (event) => {
         const db = event.target.result;
@@ -1007,18 +1034,70 @@ var IndexedDBTokenStorageProvider = class {
       request.onsuccess = () => resolve();
     });
   }
-  clearStore(storeName) {
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        resolve();
-        return;
+  /**
+   * Find all IndexedDB databases with our prefix.
+   * Returns empty array if indexedDB.databases() is unavailable (older browsers).
+   */
+  async findPrefixedDatabases() {
+    if (typeof indexedDB.databases !== "function") return [];
+    try {
+      const allDbs = await Promise.race([
+        indexedDB.databases(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("databases() timed out")), 1500)
+        )
+      ]);
+      return allDbs.map((info) => info.name).filter((name) => !!name && name.startsWith(this.dbNamePrefix));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clear all object stores in a single database.
+   * Opens a temporary connection, clears STORE_TOKENS and STORE_META, then closes.
+   * Uses IDBObjectStore.clear() which is a normal readwrite transaction — cannot
+   * be blocked by other connections (unlike deleteDatabase()).
+   */
+  async clearDatabaseStores(dbName) {
+    const db = await Promise.race([
+      new Promise((resolve, reject) => {
+        const req = indexedDB.open(dbName, DB_VERSION2);
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => {
+          const db2 = req.result;
+          db2.onversionchange = () => {
+            db2.close();
+          };
+          resolve(db2);
+        };
+        req.onupgradeneeded = (event) => {
+          const db2 = event.target.result;
+          if (!db2.objectStoreNames.contains(STORE_TOKENS)) {
+            db2.createObjectStore(STORE_TOKENS, { keyPath: "id" });
+          }
+          if (!db2.objectStoreNames.contains(STORE_META)) {
+            db2.createObjectStore(STORE_META);
+          }
+        };
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`open timed out: ${dbName}`)), 3e3)
+      )
+    ]);
+    try {
+      for (const storeName of [STORE_TOKENS, STORE_META]) {
+        if (db.objectStoreNames.contains(storeName)) {
+          await new Promise((resolve, reject) => {
+            const tx = db.transaction(storeName, "readwrite");
+            const req = tx.objectStore(storeName).clear();
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => resolve();
+          });
+        }
       }
-      const transaction = this.db.transaction(storeName, "readwrite");
-      const store = transaction.objectStore(storeName);
-      const request = store.clear();
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve();
-    });
+    } finally {
+      db.close();
+    }
   }
 };
 function createIndexedDBTokenStorageProvider(config) {