@bopen-io/wallet-toolbox 1.7.20-idb-fix.2 → 1.7.20-idb-fix.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bopen-io/wallet-toolbox",
-  "version": "1.7.20-idb-fix.2",
+  "version": "1.7.20-idb-fix.5",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/storage/WalletStorageManager.ts

@@ -744,23 +744,27 @@ export class WalletStorageManager implements sdk.WalletStorage {
     const identityKey = auth.identityKey
 
     const writerSettings = await writer.makeAvailable()
+    const isRemoteWriter = writer instanceof StorageClient
 
     let inserts = 0,
       updates = 0
 
-    log = await this.runAsSync(async sync => {
-      const reader = sync
-      const readerSettings = reader.getSettings()
-
+    // If writer is remote (StorageClient), we must NOT hold a local IDB transaction
+    // across network calls. Instead, do fresh reads for each chunk iteration.
+    if (isRemoteWriter && !activeSync) {
+      const readerSettings = this.getSettings()
       log += progLog(`syncToWriter from ${readerSettings.storageName} to ${writerSettings.storageName}\n`)
 
       let i = -1
       for (;;) {
         i++
+        // Network call to remote writer - OK, no local transaction held
         const ss = await EntitySyncState.fromStorage(writer, identityKey, readerSettings)
         const args = ss.makeRequestSyncChunkArgs(identityKey, writerSettings.storageIdentityKey)
-        const chunk = await reader.getSyncChunk(args)
+        // Fresh local read - brief transaction that completes before network call
+        const chunk = await this.runAsSync(async sync => sync.getSyncChunk(args))
         log += EntitySyncState.syncChunkSummary(chunk)
+        // Network call to remote writer - OK, no local transaction held
         const r = await writer.processSyncChunk(args, chunk)
         inserts += r.inserts
         updates += r.updates
@@ -768,8 +772,31 @@ export class WalletStorageManager implements sdk.WalletStorage {
         if (r.done) break
       }
       log += progLog(`syncToWriter complete: ${inserts} inserts, ${updates} updates\n`)
-      return log
-    }, activeSync)
+    } else {
+      // Writer is local or we have an active sync context - use original approach
+      log = await this.runAsSync(async sync => {
+        const reader = sync
+        const readerSettings = reader.getSettings()
+
+        log += progLog(`syncToWriter from ${readerSettings.storageName} to ${writerSettings.storageName}\n`)
+
+        let i = -1
+        for (;;) {
+          i++
+          const ss = await EntitySyncState.fromStorage(writer, identityKey, readerSettings)
+          const args = ss.makeRequestSyncChunkArgs(identityKey, writerSettings.storageIdentityKey)
+          const chunk = await reader.getSyncChunk(args)
+          log += EntitySyncState.syncChunkSummary(chunk)
+          const r = await writer.processSyncChunk(args, chunk)
+          inserts += r.inserts
+          updates += r.updates
+          log += progLog(`chunk ${i} inserted ${r.inserts} updated ${r.updates} ${r.maxUpdated_at}\n`)
+          if (r.done) break
+        }
+        log += progLog(`syncToWriter complete: ${inserts} inserts, ${updates} updates\n`)
+        return log
+      }, activeSync)
+    }
 
     return { inserts, updates, log }
   }
@@ -817,38 +844,55 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
     log += progLog('\n')
 
-    log += await this.runAsSync(async sync => {
-      let log = ''
-
-      if (this._conflictingActives!.length > 0) {
-        // Merge state from conflicting actives into `newActive`.
-
-        // Handle case where new active is current active to resolve conflicts.
-        // And where new active is one of the current conflict actives.
-        this._conflictingActives!.push(this._active!)
-        // Remove the new active from conflicting actives and
-        // set new active as the conflicting active that matches the target `storageIdentityKey`
-        this._conflictingActives = this._conflictingActives!.filter(ca => {
-          const isNewActive = ca.settings!.storageIdentityKey === storageIdentityKey
-          return !isNewActive
-        })
-
-        // Merge state from conflicting actives into `newActive`.
-        for (const conflict of this._conflictingActives) {
-          log += progLog('MERGING STATE FROM CONFLICTING ACTIVES:\n')
-          const sfr = await this.syncToWriter(
-            { identityKey, userId: newActive.user!.userId, isActive: false },
-            newActive.storage,
-            conflict.storage,
-            undefined,
-            progLog
-          )
-          log += sfr.log
+    // Handle conflicting actives OUTSIDE runAsSync to avoid IDB timeout.
+    // Network calls to remote storage can take longer than IDB transaction timeout.
+    if (this._conflictingActives!.length > 0) {
+      // Handle case where new active is current active to resolve conflicts.
+      // And where new active is one of the current conflict actives.
+      this._conflictingActives!.push(this._active!)
+      // Remove the new active from conflicting actives
+      this._conflictingActives = this._conflictingActives!.filter(ca => {
+        const isNewActive = ca.settings!.storageIdentityKey === storageIdentityKey
+        return !isNewActive
+      })
+
+      // Merge state from each conflicting active into newActive.
+      // Network calls happen here, outside any held IDB transaction.
+      for (const conflict of this._conflictingActives) {
+        log += progLog('MERGING STATE FROM CONFLICTING ACTIVES:\n')
+        const readerSettings = await conflict.storage.makeAvailable()
+        const writerSettings = await newActive.storage.makeAvailable()
+
+        let i = -1
+        for (;;) {
+          i++
+          // Get sync state from writer (newActive) - brief local read
+          const ss = await EntitySyncState.fromStorage(newActive.storage, identityKey, readerSettings)
+          const args = ss.makeRequestSyncChunkArgs(identityKey, writerSettings.storageIdentityKey)
+
+          // Network call to conflict (reader) - outside transaction
+          const chunk = await conflict.storage.getSyncChunk(args)
+          log += EntitySyncState.syncChunkSummary(chunk)
+
+          // Preserve activeStorage - merging from reader cannot change active
+          if (chunk.user) {
+            chunk.user.activeStorage = storageIdentityKey
+          }
+
+          // Brief local write per chunk
+          const r = await newActive.storage.processSyncChunk(args, chunk)
+          log += progLog(`chunk ${i} inserted ${r.inserts} updated ${r.updates} ${r.maxUpdated_at}\n`)
+          if (r.done) break
         }
-        log += progLog('PROPAGATE MERGED ACTIVE STATE TO NON-ACTIVES\n')
-      } else {
-        log += progLog('BACKUP CURRENT ACTIVE STATE THEN SET NEW ACTIVE\n')
       }
+      log += progLog('PROPAGATE MERGED ACTIVE STATE TO NON-ACTIVES\n')
+    } else {
+      log += progLog('BACKUP CURRENT ACTIVE STATE THEN SET NEW ACTIVE\n')
+    }
+
+    // Continue with local-only operations in runAsSync
+    log += await this.runAsSync(async sync => {
+      let innerLog = ''
 
       // If there were conflicting actives,
       // Push state merged from all merged actives into newActive to all stores other than the now single active.
@@ -869,18 +913,18 @@ export class WalletStorageManager implements sdk.WalletStorage {
           const stwr = await this.syncToWriter(
             { identityKey, userId: store.user!.userId, isActive: false },
             store.storage,
-            backupSource.storage,
+            sync,
             undefined,
             progLog
           )
-          log += stwr.log
+          innerLog += stwr.log
         }
       }
 
       this._isAvailable = false
       await this.makeAvailable()
 
-      return log
+      return innerLog
     })
 
     return log