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

package/package.json

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

package/src/storage/StorageIdb.ts

@@ -114,6 +114,17 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
   ): IDBPTransaction<StorageIdbSchema, string[], 'readwrite' | 'readonly'> {
     if (trx) {
       const t = trx as IDBPTransaction<StorageIdbSchema, string[], 'readwrite' | 'readonly'>
+      // Check if the transaction is still active by trying to access an object store
+      try {
+        const storeToCheck = stores[0] || this.allStores[0]
+        t.objectStore(storeToCheck)
+      } catch (e) {
+        console.error(
+          `[StorageIdb.toDbTrx] Passed transaction already finished! stores=${stores.join(',')}, mode=${mode}`
+        )
+        console.error('[StorageIdb.toDbTrx] Stack trace:', new Error().stack)
+        throw e
+      }
       return t
     } else {
       if (!this.db) throw new Error('not initialized')
@@ -357,7 +368,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     excludeSending: boolean,
     transactionId: number
   ): Promise<TableOutput | undefined> {
-    const dbTrx = this.toDbTrx(['outputs', 'transactions'], 'readwrite')
+    // Include proven_txs in store list since findOutputs -> validateOutputScript needs it
+    const dbTrx = this.toDbTrx(['outputs', 'transactions', 'proven_txs'], 'readwrite')
     try {
       const txStatus: TransactionStatus[] = ['completed', 'unproven']
       if (!excludeSending) txStatus.push('sending')
@@ -519,21 +531,36 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     filtered: (v: TableOutputTagMap) => void,
     userId?: number
   ): Promise<void> {
+    // Pre-compute outputTagIds for this user BEFORE opening cursor.
+    // This avoids nested queries inside the cursor loop which cause IDB transaction timeouts.
+    let userOutputTagIds: Set<number> | undefined
+    if (userId !== undefined) {
+      userOutputTagIds = new Set<number>()
+      const userTags = await this.findOutputTags({ partial: { userId } })
+      for (const tag of userTags) {
+        userOutputTagIds.add(tag.outputTagId)
+      }
+    }
+
     const offset = args.paged?.offset || 0
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['output_tags_map'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags_map', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags_map', 'outputTagId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags_map', 'outputId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.outputTagId !== undefined) {
-      cursor = await dbTrx.objectStore('output_tags_map').index('outputTagId').openCursor(args.partial.outputTagId)
+      cursor = await dbTrx
+        .objectStore('output_tags_map')
+        .index('outputTagId')
+        .openCursor(args.partial.outputTagId, direction)
     } else if (args.partial?.outputId !== undefined) {
-      cursor = await dbTrx.objectStore('output_tags_map').index('outputId').openCursor(args.partial.outputId)
+      cursor = await dbTrx.objectStore('output_tags_map').index('outputId').openCursor(args.partial.outputId, direction)
     } else {
-      cursor = await dbTrx.objectStore('output_tags_map').openCursor()
+      cursor = await dbTrx.objectStore('output_tags_map').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -550,9 +577,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
         if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
       }
-      if (userId !== undefined && r.txid) {
-        const count = await this.countOutputTags({ partial: { userId, outputTagId: r.outputTagId }, trx: args.trx })
-        if (count === 0) continue
+      if (userOutputTagIds !== undefined && !userOutputTagIds.has(r.outputTagId)) {
+        continue
       }
       if (skipped < offset) {
         skipped++
@@ -585,10 +611,25 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         'args.partial.inputBEEF',
         `undefined. ProvenTxReqs may not be found by inputBEEF value.`
       )
+
+    // Pre-compute txids for this user's transactions BEFORE opening cursor.
+    // This avoids nested queries inside the cursor loop which cause IDB transaction timeouts.
+    let userTxIds: Set<string> | undefined
+    if (userId !== undefined) {
+      userTxIds = new Set<string>()
+      const userTxs = await this.findTransactions({ partial: { userId }, noRawTx: true })
+      for (const tx of userTxs) {
+        if (tx.txid) {
+          userTxIds.add(tx.txid)
+        }
+      }
+    }
+
     const offset = args.paged?.offset || 0
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['proven_tx_reqs'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', 'provenTxId', 'readwrite' | 'readonly'>
@@ -597,17 +638,20 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', 'batch', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.provenTxReqId) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').openCursor(args.partial.provenTxReqId)
+      cursor = await dbTrx.objectStore('proven_tx_reqs').openCursor(args.partial.provenTxReqId, direction)
     } else if (args.partial?.provenTxId !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('provenTxId').openCursor(args.partial.provenTxId)
+      cursor = await dbTrx
+        .objectStore('proven_tx_reqs')
+        .index('provenTxId')
+        .openCursor(args.partial.provenTxId, direction)
     } else if (args.partial?.txid !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('txid').openCursor(args.partial.txid)
+      cursor = await dbTrx.objectStore('proven_tx_reqs').index('txid').openCursor(args.partial.txid, direction)
     } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('status').openCursor(args.partial.status)
+      cursor = await dbTrx.objectStore('proven_tx_reqs').index('status').openCursor(args.partial.status, direction)
     } else if (args.partial?.batch !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('batch').openCursor(args.partial.batch)
+      cursor = await dbTrx.objectStore('proven_tx_reqs').index('batch').openCursor(args.partial.batch, direction)
     } else {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').openCursor()
+      cursor = await dbTrx.objectStore('proven_tx_reqs').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -616,6 +660,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       firstTime = false
       const r = cursor.value
       if (args.since && args.since > r.updated_at) continue
+      if (args.status && args.status.length > 0 && !args.status.includes(r.status)) continue
+      if (args.txids && args.txids.length > 0 && !args.txids.includes(r.txid)) continue
       if (args.partial) {
         if (args.partial.provenTxReqId && r.provenTxReqId !== args.partial.provenTxReqId) continue
         if (args.partial.provenTxId && r.provenTxId !== args.partial.provenTxId) continue
@@ -629,9 +675,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         if (args.partial.history && r.history !== args.partial.history) continue
         if (args.partial.notify && r.notify !== args.partial.notify) continue
       }
-      if (userId !== undefined && r.txid) {
-        const count = await this.countTransactions({ partial: { userId, txid: r.txid }, trx: args.trx })
-        if (count === 0) continue
+      if (userTxIds !== undefined && r.txid && !userTxIds.has(r.txid)) {
+        continue
       }
       if (skipped < offset) {
         skipped++
@@ -660,20 +705,35 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         'args.partial.merklePath',
         `undefined. ProvenTxs may not be found by merklePath value.`
       )
+
+    // Pre-compute provenTxIds for this user's transactions BEFORE opening cursor.
+    // This avoids nested queries inside the cursor loop which cause IDB transaction timeouts.
+    let userProvenTxIds: Set<number> | undefined
+    if (userId !== undefined) {
+      userProvenTxIds = new Set<number>()
+      const userTxs = await this.findTransactions({ partial: { userId }, noRawTx: true })
+      for (const tx of userTxs) {
+        if (tx.provenTxId !== undefined) {
+          userProvenTxIds.add(tx.provenTxId)
+        }
+      }
+    }
+
     const offset = args.paged?.offset || 0
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['proven_txs'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_txs', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_txs', 'txid', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.provenTxId) {
-      cursor = await dbTrx.objectStore('proven_txs').openCursor(args.partial.provenTxId)
+      cursor = await dbTrx.objectStore('proven_txs').openCursor(args.partial.provenTxId, direction)
     } else if (args.partial?.txid !== undefined) {
-      cursor = await dbTrx.objectStore('proven_txs').index('txid').openCursor(args.partial.txid)
+      cursor = await dbTrx.objectStore('proven_txs').index('txid').openCursor(args.partial.txid, direction)
     } else {
-      cursor = await dbTrx.objectStore('proven_txs').openCursor()
+      cursor = await dbTrx.objectStore('proven_txs').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -692,9 +752,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         if (args.partial.blockHash && r.blockHash !== args.partial.blockHash) continue
         if (args.partial.merkleRoot && r.merkleRoot !== args.partial.merkleRoot) continue
       }
-      if (userId !== undefined) {
-        const count = await this.countTransactions({ partial: { userId, provenTxId: r.provenTxId }, trx: args.trx })
-        if (count === 0) continue
+      if (userProvenTxIds !== undefined && !userProvenTxIds.has(r.provenTxId)) {
+        continue
       }
       if (skipped < offset) {
         skipped++
@@ -720,21 +779,36 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     filtered: (v: TableTxLabelMap) => void,
     userId?: number
   ): Promise<void> {
+    // Pre-compute txLabelIds for this user BEFORE opening cursor.
+    // This avoids nested queries inside the cursor loop which cause IDB transaction timeouts.
+    let userTxLabelIds: Set<number> | undefined
+    if (userId !== undefined) {
+      userTxLabelIds = new Set<number>()
+      const userLabels = await this.findTxLabels({ partial: { userId } })
+      for (const label of userLabels) {
+        userTxLabelIds.add(label.txLabelId)
+      }
+    }
+
     const offset = args.paged?.offset || 0
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['tx_labels_map'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels_map', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels_map', 'transactionId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels_map', 'txLabelId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.transactionId !== undefined) {
-      cursor = await dbTrx.objectStore('tx_labels_map').index('transactionId').openCursor(args.partial.transactionId)
+      cursor = await dbTrx
+        .objectStore('tx_labels_map')
+        .index('transactionId')
+        .openCursor(args.partial.transactionId, direction)
     } else if (args.partial?.txLabelId !== undefined) {
-      cursor = await dbTrx.objectStore('tx_labels_map').index('txLabelId').openCursor(args.partial.txLabelId)
+      cursor = await dbTrx.objectStore('tx_labels_map').index('txLabelId').openCursor(args.partial.txLabelId, direction)
     } else {
-      cursor = await dbTrx.objectStore('tx_labels_map').openCursor()
+      cursor = await dbTrx.objectStore('tx_labels_map').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -743,6 +817,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       firstTime = false
       const r = cursor.value
       if (args.since && args.since > r.updated_at) continue
+      if (args.labelIds && !args.labelIds.includes(r.txLabelId)) continue
       if (args.partial) {
         if (args.partial.txLabelId && r.txLabelId !== args.partial.txLabelId) continue
         if (args.partial.transactionId && r.transactionId !== args.partial.transactionId) continue
@@ -750,9 +825,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
         if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
       }
-      if (userId !== undefined) {
-        const count = await this.countTxLabels({ partial: { userId, txLabelId: r.txLabelId }, trx: args.trx })
-        if (count === 0) continue
+      if (userTxLabelIds !== undefined && !userTxLabelIds.has(r.txLabelId)) {
+        continue
       }
       if (skipped < offset) {
         skipped++
@@ -1014,7 +1088,16 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     }
     const u = this.validatePartialForUpdate(update)
     const dbTrx = this.toDbTrx([storeName], 'readwrite', trx)
-    const store = dbTrx.objectStore(storeName)
+    let store: any
+    try {
+      store = dbTrx.objectStore(storeName)
+    } catch (e) {
+      console.error(
+        `[StorageIdb.updateIdb] objectStore('${storeName}') failed for id=${JSON.stringify(id)}, trx=${!!trx}:`,
+        e
+      )
+      throw e
+    }
     const ids = Array.isArray(id) ? id : [id]
     try {
       for (const i of ids) {
@@ -1189,7 +1272,13 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       await tx.done
       return r
     } catch (err) {
-      tx.abort()
+      // Log more detail about transaction errors to help debug IDB issues
+      console.error('[StorageIdb] Transaction error:', err instanceof Error ? err.message : err)
+      try {
+        tx.abort()
+      } catch (abortErr) {
+        console.error('[StorageIdb] Error aborting transaction:', abortErr)
+      }
       await tx.done
       throw err
     }
@@ -1203,6 +1292,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['certificate_fields'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificate_fields', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificate_fields', 'userId', 'readwrite' | 'readonly'>
@@ -1212,11 +1302,11 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       cursor = await dbTrx
         .objectStore('certificate_fields')
         .index('certificateId')
-        .openCursor(args.partial.certificateId)
+        .openCursor(args.partial.certificateId, direction)
     } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('certificate_fields').index('userId').openCursor(args.partial.userId)
+      cursor = await dbTrx.objectStore('certificate_fields').index('userId').openCursor(args.partial.userId, direction)
     } else {
-      cursor = await dbTrx.objectStore('certificate_fields').openCursor()
+      cursor = await dbTrx.objectStore('certificate_fields').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1258,6 +1348,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['certificates'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificates', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificates', 'userId', 'readwrite' | 'readonly'>
@@ -1270,18 +1361,21 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         >
       | null
     if (args.partial?.certificateId) {
-      cursor = await dbTrx.objectStore('certificates').openCursor(args.partial.certificateId)
+      cursor = await dbTrx.objectStore('certificates').openCursor(args.partial.certificateId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.type && args.partial?.certifier && args.partial?.serialNumber) {
         cursor = await dbTrx
           .objectStore('certificates')
           .index('userId_type_certifier_serialNumber')
-          .openCursor([args.partial.userId, args.partial.type, args.partial.certifier, args.partial.serialNumber])
+          .openCursor(
+            [args.partial.userId, args.partial.type, args.partial.certifier, args.partial.serialNumber],
+            direction
+          )
       } else {
-        cursor = await dbTrx.objectStore('certificates').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('certificates').index('userId').openCursor(args.partial.userId, direction)
       }
     } else {
-      cursor = await dbTrx.objectStore('certificates').openCursor()
+      cursor = await dbTrx.objectStore('certificates').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1341,19 +1435,23 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['commissions'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'commissions', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'commissions', 'userId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'commissions', 'transactionId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.commissionId) {
-      cursor = await dbTrx.objectStore('commissions').openCursor(args.partial.commissionId)
+      cursor = await dbTrx.objectStore('commissions').openCursor(args.partial.commissionId, direction)
     } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('commissions').index('userId').openCursor(args.partial.userId)
+      cursor = await dbTrx.objectStore('commissions').index('userId').openCursor(args.partial.userId, direction)
     } else if (args.partial?.transactionId !== undefined) {
-      cursor = await dbTrx.objectStore('commissions').index('transactionId').openCursor(args.partial.transactionId)
+      cursor = await dbTrx
+        .objectStore('commissions')
+        .index('transactionId')
+        .openCursor(args.partial.transactionId, direction)
     } else {
-      cursor = await dbTrx.objectStore('commissions').openCursor()
+      cursor = await dbTrx.objectStore('commissions').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1396,6 +1494,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['monitor_events'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor: IDBPCursorWithValue<
       StorageIdbSchema,
       string[],
@@ -1404,9 +1503,9 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       'readwrite' | 'readonly'
     > | null
     if (args.partial?.id) {
-      cursor = await dbTrx.objectStore('monitor_events').openCursor(args.partial.id)
+      cursor = await dbTrx.objectStore('monitor_events').openCursor(args.partial.id, direction)
     } else {
-      cursor = await dbTrx.objectStore('monitor_events').openCursor()
+      cursor = await dbTrx.objectStore('monitor_events').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1446,24 +1545,25 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['output_baskets'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_baskets', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_baskets', 'userId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_baskets', 'name_userId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.basketId) {
-      cursor = await dbTrx.objectStore('output_baskets').openCursor(args.partial.basketId)
+      cursor = await dbTrx.objectStore('output_baskets').openCursor(args.partial.basketId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.name !== undefined) {
         cursor = await dbTrx
           .objectStore('output_baskets')
           .index('name_userId')
-          .openCursor([args.partial.name, args.partial.userId])
+          .openCursor([args.partial.name, args.partial.userId], direction)
       } else {
-        cursor = await dbTrx.objectStore('output_baskets').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('output_baskets').index('userId').openCursor(args.partial.userId, direction)
       }
     } else {
-      cursor = await dbTrx.objectStore('output_baskets').openCursor()
+      cursor = await dbTrx.objectStore('output_baskets').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1485,7 +1585,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
           continue
         if (
           args.partial.minimumDesiredUTXOValue !== undefined &&
-          r.numberOfDesiredSatoshis !== args.partial.minimumDesiredUTXOValue
+          r.minimumDesiredUTXOValue !== args.partial.minimumDesiredUTXOValue
         )
           continue
         if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
@@ -1533,6 +1633,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       stores.push('transactions')
     }
     const dbTrx = this.toDbTrx(stores, 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'userId', 'readwrite' | 'readonly'>
@@ -1548,24 +1649,27 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'spentBy', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.outputId) {
-      cursor = await dbTrx.objectStore('outputs').openCursor(args.partial.outputId)
+      cursor = await dbTrx.objectStore('outputs').openCursor(args.partial.outputId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.transactionId && args.partial?.vout !== undefined) {
         cursor = await dbTrx
           .objectStore('outputs')
           .index('transactionId_vout_userId')
-          .openCursor([args.partial.transactionId, args.partial.vout, args.partial.userId])
+          .openCursor([args.partial.transactionId, args.partial.vout, args.partial.userId], direction)
       } else {
-        cursor = await dbTrx.objectStore('outputs').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('outputs').index('userId').openCursor(args.partial.userId, direction)
       }
     } else if (args.partial?.transactionId !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('transactionId').openCursor(args.partial.transactionId)
+      cursor = await dbTrx
+        .objectStore('outputs')
+        .index('transactionId')
+        .openCursor(args.partial.transactionId, direction)
     } else if (args.partial?.basketId !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('basketId').openCursor(args.partial.basketId)
+      cursor = await dbTrx.objectStore('outputs').index('basketId').openCursor(args.partial.basketId, direction)
     } else if (args.partial?.spentBy !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('spentBy').openCursor(args.partial.spentBy)
+      cursor = await dbTrx.objectStore('outputs').index('spentBy').openCursor(args.partial.spentBy, direction)
     } else {
-      cursor = await dbTrx.objectStore('outputs').openCursor()
+      cursor = await dbTrx.objectStore('outputs').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1649,7 +1753,9 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     )
     for (const o of results) {
       if (!args.noScript) {
-        await this.validateOutputScript(o)
+        // Pass the transaction to avoid creating separate IDB operations
+        // that would cause a passed transaction to auto-commit
+        await this.validateOutputScript(o, args.trx)
       } else {
         o.lockingScript = undefined
       }
@@ -1662,24 +1768,25 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['output_tags'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags', 'userId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'output_tags', 'tag_userId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.outputTagId) {
-      cursor = await dbTrx.objectStore('output_tags').openCursor(args.partial.outputTagId)
+      cursor = await dbTrx.objectStore('output_tags').openCursor(args.partial.outputTagId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.tag !== undefined) {
         cursor = await dbTrx
           .objectStore('output_tags')
           .index('tag_userId')
-          .openCursor([args.partial.tag, args.partial.userId])
+          .openCursor([args.partial.tag, args.partial.userId], direction)
       } else {
-        cursor = await dbTrx.objectStore('output_tags').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('output_tags').index('userId').openCursor(args.partial.userId, direction)
       }
     } else {
-      cursor = await dbTrx.objectStore('output_tags').openCursor()
+      cursor = await dbTrx.objectStore('output_tags').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1725,6 +1832,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['sync_states'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', 'userId', 'readwrite' | 'readonly'>
@@ -1732,15 +1840,15 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', 'status', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.syncStateId) {
-      cursor = await dbTrx.objectStore('sync_states').openCursor(args.partial.syncStateId)
+      cursor = await dbTrx.objectStore('sync_states').openCursor(args.partial.syncStateId, direction)
     } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('userId').openCursor(args.partial.userId)
+      cursor = await dbTrx.objectStore('sync_states').index('userId').openCursor(args.partial.userId, direction)
     } else if (args.partial?.refNum !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('refNum').openCursor(args.partial.refNum)
+      cursor = await dbTrx.objectStore('sync_states').index('refNum').openCursor(args.partial.refNum, direction)
     } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('status').openCursor(args.partial.status)
+      cursor = await dbTrx.objectStore('sync_states').index('status').openCursor(args.partial.status, direction)
     } else {
-      cursor = await dbTrx.objectStore('sync_states').openCursor()
+      cursor = await dbTrx.objectStore('sync_states').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1761,7 +1869,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
         if (args.partial.refNum !== undefined && r.refNum !== args.partial.refNum) continue
         if (args.partial.when && r.when?.getTime() !== args.partial.when.getTime()) continue
         if (args.partial.satoshis !== undefined && r.satoshis !== args.partial.satoshis) continue
-        if (args.partial.errorLocal && r.errorLocale !== args.partial.errorLocal) continue
+        if (args.partial.errorLocal && r.errorLocal !== args.partial.errorLocal) continue
         if (args.partial.errorOther && r.errorOther !== args.partial.errorOther) continue
       }
       if (skipped < offset) {
@@ -1804,6 +1912,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       stores.push('tx_labels_map')
     }
     const dbTrx = this.toDbTrx(stores, 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'userId', 'readwrite' | 'readonly'>
@@ -1813,24 +1922,27 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'reference', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.transactionId) {
-      cursor = await dbTrx.objectStore('transactions').openCursor(args.partial.transactionId)
+      cursor = await dbTrx.objectStore('transactions').openCursor(args.partial.transactionId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.status !== undefined) {
         cursor = await dbTrx
           .objectStore('transactions')
           .index('status_userId')
-          .openCursor([args.partial.status, args.partial.userId])
+          .openCursor([args.partial.status, args.partial.userId], direction)
       } else {
-        cursor = await dbTrx.objectStore('transactions').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('transactions').index('userId').openCursor(args.partial.userId, direction)
       }
     } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('status').openCursor(args.partial.status)
+      cursor = await dbTrx.objectStore('transactions').index('status').openCursor(args.partial.status, direction)
     } else if (args.partial?.provenTxId !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('provenTxId').openCursor(args.partial.provenTxId)
+      cursor = await dbTrx
+        .objectStore('transactions')
+        .index('provenTxId')
+        .openCursor(args.partial.provenTxId, direction)
     } else if (args.partial?.reference !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('reference').openCursor(args.partial.reference)
+      cursor = await dbTrx.objectStore('transactions').index('reference').openCursor(args.partial.reference, direction)
     } else {
-      cursor = await dbTrx.objectStore('transactions').openCursor()
+      cursor = await dbTrx.objectStore('transactions').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1912,24 +2024,25 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['tx_labels'], 'readonly', args.trx)
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
     let cursor:
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels', unknown, 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels', 'userId', 'readwrite' | 'readonly'>
       | IDBPCursorWithValue<StorageIdbSchema, string[], 'tx_labels', 'label_userId', 'readwrite' | 'readonly'>
       | null
     if (args.partial?.txLabelId) {
-      cursor = await dbTrx.objectStore('tx_labels').openCursor(args.partial.txLabelId)
+      cursor = await dbTrx.objectStore('tx_labels').openCursor(args.partial.txLabelId, direction)
     } else if (args.partial?.userId !== undefined) {
       if (args.partial?.label !== undefined) {
         cursor = await dbTrx
           .objectStore('tx_labels')
           .index('label_userId')
-          .openCursor([args.partial.label, args.partial.userId])
+          .openCursor([args.partial.label, args.partial.userId], direction)
       } else {
-        cursor = await dbTrx.objectStore('tx_labels').index('userId').openCursor(args.partial.userId)
+        cursor = await dbTrx.objectStore('tx_labels').index('userId').openCursor(args.partial.userId, direction)
       }
     } else {
-      cursor = await dbTrx.objectStore('tx_labels').openCursor()
+      cursor = await dbTrx.objectStore('tx_labels').openCursor(null, direction)
     }
     let firstTime = true
     while (cursor) {
@@ -1970,7 +2083,8 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     let skipped = 0
     let count = 0
     const dbTrx = this.toDbTrx(['users'], 'readonly', args.trx)
-    let cursor = await dbTrx.objectStore('users').openCursor()
+    const direction: IDBCursorDirection = args.orderDescending ? 'prev' : 'next'
+    let cursor = await dbTrx.objectStore('users').openCursor(null, direction)
     let firstTime = true
     while (cursor) {
       if (!firstTime) cursor = await cursor.continue()