@bopen-io/wallet-toolbox 1.7.20-idb-fix.1 → 1.7.20-idb-fix.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bopen-io/wallet-toolbox",
-  "version": "1.7.20-idb-fix.1",
+  "version": "1.7.20-idb-fix.4",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.2.3",
     "@bsv/payment-express-middleware": "^1.2.3",
-    "@bsv/sdk": "^1.10.1",
+    "@bsv/sdk": "^1.9.29",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/storage/StorageIdb.ts

@@ -546,17 +546,21 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     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) {
@@ -625,6 +629,7 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     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'>
@@ -633,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) {
@@ -652,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
@@ -713,16 +723,17 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     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) {
@@ -783,17 +794,21 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     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) {
@@ -802,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
@@ -1276,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'>
@@ -1285,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) {
@@ -1331,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'>
@@ -1343,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) {
@@ -1414,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) {
@@ -1469,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[],
@@ -1477,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) {
@@ -1519,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) {
@@ -1558,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
@@ -1606,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'>
@@ -1621,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) {
@@ -1737,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) {
@@ -1800,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'>
@@ -1807,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) {
@@ -1836,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) {
@@ -1879,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'>
@@ -1888,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) {
@@ -1987,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) {
@@ -2045,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()

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 }
   }