@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/src/storage/StorageIdb.ts

@@ -1,2304 +0,0 @@
-import { deleteDB, IDBPCursorWithValue, IDBPDatabase, IDBPTransaction, openDB } from 'idb'
-import { ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
-import {
-  TableCertificate,
-  TableCertificateField,
-  TableCertificateX,
-  TableCommission,
-  TableMonitorEvent,
-  TableOutput,
-  TableOutputBasket,
-  TableOutputTag,
-  TableOutputTagMap,
-  TableProvenTx,
-  TableProvenTxReq,
-  TableSettings,
-  TableSyncState,
-  TableTransaction,
-  TableTxLabel,
-  TableTxLabelMap,
-  TableUser
-} from './schema/tables'
-import { verifyOne, verifyOneOrNone } from '../utility/utilityHelpers'
-import { StorageAdminStats, StorageProvider, StorageProviderOptions } from './StorageProvider'
-import { StorageIdbSchema } from './schema/StorageIdbSchema'
-import { DBType } from './StorageReader'
-import { listActionsIdb } from './methods/listActionsIdb'
-import { listOutputsIdb } from './methods/listOutputsIdb'
-import { reviewStatusIdb } from './methods/reviewStatusIdb'
-import { purgeDataIdb } from './methods/purgeDataIdb'
-import {
-  AuthId,
-  FindCertificateFieldsArgs,
-  FindCertificatesArgs,
-  FindCommissionsArgs,
-  FindForUserSincePagedArgs,
-  FindMonitorEventsArgs,
-  FindOutputBasketsArgs,
-  FindOutputsArgs,
-  FindOutputTagMapsArgs,
-  FindOutputTagsArgs,
-  FindProvenTxReqsArgs,
-  FindProvenTxsArgs,
-  FindSyncStatesArgs,
-  FindTransactionsArgs,
-  FindTxLabelMapsArgs,
-  FindTxLabelsArgs,
-  FindUsersArgs,
-  ProvenOrRawTx,
-  PurgeParams,
-  PurgeResults,
-  TrxToken,
-  WalletStorageProvider
-} from '../sdk/WalletStorage.interfaces'
-import { WERR_INTERNAL, WERR_INVALID_OPERATION, WERR_INVALID_PARAMETER, WERR_UNAUTHORIZED } from '../sdk/WERR_errors'
-import { EntityTimeStamp, TransactionStatus } from '../sdk/types'
-
-export interface StorageIdbOptions extends StorageProviderOptions {}
-
-/**
- * This class implements the `StorageProvider` interface using IndexedDB,
- * via the promises wrapper package `idb`.
- */
-export class StorageIdb extends StorageProvider implements WalletStorageProvider {
-  dbName: string
-  db?: IDBPDatabase<StorageIdbSchema>
-
-  constructor(options: StorageIdbOptions) {
-    super(options)
-    this.dbName = `wallet-toolbox-${this.chain}net`
-  }
-
-  /**
-   * This method must be called at least once before any other method accesses the database,
-   * and each time the schema may have updated.
-   *
-   * If the database has already been created in this context, `storageName` and `storageIdentityKey`
-   * are ignored.
-   *
-   * @param storageName
-   * @param storageIdentityKey
-   * @returns
-   */
-  async migrate(storageName: string, storageIdentityKey: string): Promise<string> {
-    const db = await this.verifyDB(storageName, storageIdentityKey)
-    return db.version.toString()
-  }
-
-  /**
-   * Following initial database initialization, this method verfies that db is ready for use.
-   *
-   * @throws `WERR_INVALID_OPERATION` if the database has not been initialized by a call to `migrate`.
-   *
-   * @param storageName
-   * @param storageIdentityKey
-   *
-   * @returns
-   */
-  async verifyDB(storageName?: string, storageIdentityKey?: string): Promise<IDBPDatabase<StorageIdbSchema>> {
-    if (this.db) return this.db
-    this.db = await this.initDB(storageName, storageIdentityKey)
-    this._settings = (await this.db.getAll('settings'))[0]
-    this.whenLastAccess = new Date()
-    return this.db
-  }
-
-  /**
-   * Convert the standard optional `TrxToken` parameter into either a direct knex database instance,
-   * or a Knex.Transaction as appropriate.
-   */
-  toDbTrx(
-    stores: string[],
-    mode: 'readonly' | 'readwrite',
-    trx?: TrxToken
-  ): IDBPTransaction<StorageIdbSchema, string[], 'readwrite' | 'readonly'> {
-    if (trx) {
-      const t = trx as IDBPTransaction<StorageIdbSchema, string[], 'readwrite' | 'readonly'>
-      return t
-    } else {
-      if (!this.db) throw new Error('not initialized')
-      const db = this.db
-      const trx = db.transaction(stores || this.allStores, mode || 'readwrite')
-      this.whenLastAccess = new Date()
-      return trx
-    }
-  }
-
-  /**
-   * Called by `makeAvailable` to return storage `TableSettings`.
-   * Since this is the first async method that must be called by all clients,
-   * it is where async initialization occurs.
-   *
-   * After initialization, cached settings are returned.
-   *
-   * @param trx
-   */
-  async readSettings(trx?: TrxToken): Promise<TableSettings> {
-    await this.verifyDB()
-    return this._settings!
-  }
-
-  async initDB(storageName?: string, storageIdentityKey?: string): Promise<IDBPDatabase<StorageIdbSchema>> {
-    const chain = this.chain
-    const maxOutputScript = 1024
-    const db = await openDB<StorageIdbSchema>(this.dbName, 1, {
-      upgrade(db, oldVersion, newVersion, transaction) {
-        if (!db.objectStoreNames.contains('proven_txs')) {
-          // proven_txs object store
-          const provenTxsStore = db.createObjectStore('proven_txs', {
-            keyPath: 'provenTxId',
-            autoIncrement: true
-          })
-          provenTxsStore.createIndex('txid', 'txid', { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('proven_tx_reqs')) {
-          // proven_tx_reqs object store
-          const provenTxReqsStore = db.createObjectStore('proven_tx_reqs', {
-            keyPath: 'provenTxReqId',
-            autoIncrement: true
-          })
-          provenTxReqsStore.createIndex('provenTxId', 'provenTxId')
-          provenTxReqsStore.createIndex('txid', 'txid', { unique: true })
-          provenTxReqsStore.createIndex('status', 'status')
-          provenTxReqsStore.createIndex('batch', 'batch')
-        }
-        if (!db.objectStoreNames.contains('users')) {
-          const users = db.createObjectStore('users', {
-            keyPath: 'userId',
-            autoIncrement: true
-          })
-          users.createIndex('identityKey', 'identityKey', { unique: true })
-        }
-        if (!db.objectStoreNames.contains('certificates')) {
-          // certificates object store
-          const certificatesStore = db.createObjectStore('certificates', {
-            keyPath: 'certificateId',
-            autoIncrement: true
-          })
-          certificatesStore.createIndex('userId', 'userId')
-          certificatesStore.createIndex(
-            'userId_type_certifier_serialNumber',
-            ['userId', 'type', 'certifier', 'serialNumber'],
-            { unique: true }
-          )
-        }
-
-        if (!db.objectStoreNames.contains('certificate_fields')) {
-          // certificate_fields object store
-          const certificateFieldsStore = db.createObjectStore('certificate_fields', {
-            keyPath: ['certificateId', 'fieldName'] // Composite key
-          })
-          certificateFieldsStore.createIndex('userId', 'userId')
-          certificateFieldsStore.createIndex('certificateId', 'certificateId')
-        }
-
-        if (!db.objectStoreNames.contains('output_baskets')) {
-          // output_baskets object store
-          const outputBasketsStore = db.createObjectStore('output_baskets', {
-            keyPath: 'basketId',
-            autoIncrement: true
-          })
-          outputBasketsStore.createIndex('userId', 'userId')
-          outputBasketsStore.createIndex('name_userId', ['name', 'userId'], { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('transactions')) {
-          // transactions object store
-          const transactionsStore = db.createObjectStore('transactions', {
-            keyPath: 'transactionId',
-            autoIncrement: true
-          })
-          transactionsStore.createIndex('userId', 'userId')
-          ;(transactionsStore.createIndex('status', 'status'),
-            transactionsStore.createIndex('status_userId', ['status', 'userId']))
-          transactionsStore.createIndex('provenTxId', 'provenTxId')
-          transactionsStore.createIndex('reference', 'reference', { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('commissions')) {
-          // commissions object store
-          const commissionsStore = db.createObjectStore('commissions', {
-            keyPath: 'commissionId',
-            autoIncrement: true
-          })
-          commissionsStore.createIndex('userId', 'userId')
-          commissionsStore.createIndex('transactionId', 'transactionId', { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('outputs')) {
-          // outputs object store
-          const outputsStore = db.createObjectStore('outputs', {
-            keyPath: 'outputId',
-            autoIncrement: true
-          })
-          outputsStore.createIndex('userId', 'userId')
-          outputsStore.createIndex('transactionId', 'transactionId')
-          outputsStore.createIndex('basketId', 'basketId')
-          outputsStore.createIndex('spentBy', 'spentBy')
-          outputsStore.createIndex('transactionId_vout_userId', ['transactionId', 'vout', 'userId'], { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('output_tags')) {
-          // output_tags object store
-          const outputTagsStore = db.createObjectStore('output_tags', {
-            keyPath: 'outputTagId',
-            autoIncrement: true
-          })
-          outputTagsStore.createIndex('userId', 'userId')
-          outputTagsStore.createIndex('tag_userId', ['tag', 'userId'], { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('output_tags_map')) {
-          // output_tags_map object store
-          const outputTagsMapStore = db.createObjectStore('output_tags_map', {
-            keyPath: ['outputTagId', 'outputId']
-          })
-          outputTagsMapStore.createIndex('outputTagId', 'outputTagId')
-          outputTagsMapStore.createIndex('outputId', 'outputId')
-        }
-
-        if (!db.objectStoreNames.contains('tx_labels')) {
-          // tx_labels object store
-          const txLabelsStore = db.createObjectStore('tx_labels', {
-            keyPath: 'txLabelId',
-            autoIncrement: true
-          })
-          txLabelsStore.createIndex('userId', 'userId')
-          txLabelsStore.createIndex('label_userId', ['label', 'userId'], { unique: true })
-        }
-
-        if (!db.objectStoreNames.contains('tx_labels_map')) {
-          // tx_labels_map object store
-          const txLabelsMapStore = db.createObjectStore('tx_labels_map', {
-            keyPath: ['txLabelId', 'transactionId']
-          })
-          txLabelsMapStore.createIndex('txLabelId', 'txLabelId')
-          txLabelsMapStore.createIndex('transactionId', 'transactionId')
-        }
-
-        if (!db.objectStoreNames.contains('monitor_events')) {
-          // monitor_events object store
-          const monitorEventsStore = db.createObjectStore('monitor_events', {
-            keyPath: 'id',
-            autoIncrement: true
-          })
-        }
-
-        if (!db.objectStoreNames.contains('sync_states')) {
-          // sync_states object store
-          const syncStatesStore = db.createObjectStore('sync_states', {
-            keyPath: 'syncStateId',
-            autoIncrement: true
-          })
-          syncStatesStore.createIndex('userId', 'userId')
-          syncStatesStore.createIndex('refNum', 'refNum', { unique: true })
-          syncStatesStore.createIndex('status', 'status')
-        }
-
-        if (!db.objectStoreNames.contains('settings')) {
-          if (!storageName || !storageIdentityKey) {
-            throw new WERR_INVALID_OPERATION('migrate must be called before first access')
-          }
-          const settings = db.createObjectStore('settings', {
-            keyPath: 'storageIdentityKey'
-          })
-          const s: TableSettings = {
-            created_at: new Date(),
-            updated_at: new Date(),
-            storageIdentityKey,
-            storageName,
-            chain,
-            dbtype: 'IndexedDB',
-            maxOutputScript
-          }
-          settings.put(s)
-        }
-      }
-    })
-    return db
-  }
-
-  //
-  // StorageProvider abstract methods
-  //
-
-  async reviewStatus(args: { agedLimit: Date; trx?: TrxToken }): Promise<{ log: string }> {
-    return await reviewStatusIdb(this, args)
-  }
-
-  async purgeData(params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
-    return await purgeDataIdb(this, params, trx)
-  }
-
-  /**
-   * Proceeds in three stages:
-   * 1. Find an output that exactly funds the transaction (if exactSatoshis is not undefined).
-   * 2. Find an output that overfunds by the least amount (targetSatoshis).
-   * 3. Find an output that comes as close to funding as possible (targetSatoshis).
-   * 4. Return undefined if no output is found.
-   *
-   * Outputs must belong to userId and basketId and have spendable true.
-   * Their corresponding transaction must have status of 'completed', 'unproven', or 'sending' (if excludeSending is false).
-   *
-   * @param userId
-   * @param basketId
-   * @param targetSatoshis
-   * @param exactSatoshis
-   * @param excludeSending
-   * @param transactionId
-   * @returns next funding output to add to transaction or undefined if there are none.
-   */
-  async allocateChangeInput(
-    userId: number,
-    basketId: number,
-    targetSatoshis: number,
-    exactSatoshis: number | undefined,
-    excludeSending: boolean,
-    transactionId: number
-  ): Promise<TableOutput | undefined> {
-    const dbTrx = this.toDbTrx(['outputs', 'transactions'], 'readwrite')
-    try {
-      const txStatus: TransactionStatus[] = ['completed', 'unproven']
-      if (!excludeSending) txStatus.push('sending')
-      const args: FindOutputsArgs = {
-        partial: { userId, basketId, spendable: true },
-        txStatus,
-        trx: dbTrx
-      }
-      const outputs = await this.findOutputs(args)
-      let output: TableOutput | undefined
-      let scores: { output: TableOutput; score: number }[] = []
-      for (const o of outputs) {
-        if (exactSatoshis && o.satoshis === exactSatoshis) {
-          output = o
-          break
-        }
-        const score = o.satoshis - targetSatoshis
-        scores.push({ output: o, score })
-      }
-      if (!output) {
-        // sort scores increasing by score property
-        scores = scores.sort((a, b) => a.score - b.score)
-        // find the first score that is greater than or equal to 0
-        const o = scores.find(s => s.score >= 0)
-        if (o) {
-          // stage 2 satisfied (minimally funded)
-          output = o.output
-        } else if (scores.length > 0) {
-          // stage 3 satisfied (minimally under-funded)
-          output = scores.slice(-1)[0].output
-        } else {
-          // no available funding outputs
-          output = undefined
-        }
-      }
-      if (output) {
-        // mark output as spent by transactionId
-        await this.updateOutput(output.outputId, { spendable: false, spentBy: transactionId }, dbTrx)
-      }
-      return output
-    } finally {
-      await dbTrx.done
-    }
-  }
-
-  async getProvenOrRawTx(txid: string, trx?: TrxToken): Promise<ProvenOrRawTx> {
-    const r: ProvenOrRawTx = {
-      proven: undefined,
-      rawTx: undefined,
-      inputBEEF: undefined
-    }
-
-    r.proven = verifyOneOrNone(await this.findProvenTxs({ partial: { txid: txid }, trx }))
-    if (!r.proven) {
-      const req = verifyOneOrNone(await this.findProvenTxReqs({ partial: { txid: txid }, trx }))
-      if (req && ['unsent', 'unmined', 'unconfirmed', 'sending', 'nosend', 'completed'].includes(req.status)) {
-        r.rawTx = req.rawTx
-        r.inputBEEF = req.inputBEEF
-      }
-    }
-
-    return r
-  }
-
-  async getRawTxOfKnownValidTransaction(
-    txid?: string,
-    offset?: number,
-    length?: number,
-    trx?: TrxToken
-  ): Promise<number[] | undefined> {
-    if (!txid) return undefined
-    if (!this.isAvailable()) await this.makeAvailable()
-
-    let rawTx: number[] | undefined = undefined
-    const r = await this.getProvenOrRawTx(txid, trx)
-    if (r.proven) rawTx = r.proven.rawTx
-    else rawTx = r.rawTx
-    if (rawTx && offset !== undefined && length !== undefined && Number.isInteger(offset) && Number.isInteger(length)) {
-      rawTx = rawTx.slice(offset, offset + length)
-    }
-    return rawTx
-  }
-
-  async getLabelsForTransactionId(transactionId?: number, trx?: TrxToken): Promise<TableTxLabel[]> {
-    const maps = await this.findTxLabelMaps({ partial: { transactionId, isDeleted: false }, trx })
-    const labelIds = maps.map(m => m.txLabelId)
-    const labels: TableTxLabel[] = []
-    for (const txLabelId of labelIds) {
-      const label = verifyOne(await this.findTxLabels({ partial: { txLabelId, isDeleted: false }, trx }))
-      labels.push(label)
-    }
-    return labels
-  }
-
-  async getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]> {
-    const maps = await this.findOutputTagMaps({ partial: { outputId, isDeleted: false }, trx })
-    const tagIds = maps.map(m => m.outputTagId)
-    const tags: TableOutputTag[] = []
-    for (const outputTagId of tagIds) {
-      const tag = verifyOne(await this.findOutputTags({ partial: { outputTagId, isDeleted: false }, trx }))
-      tags.push(tag)
-    }
-    return tags
-  }
-
-  async listActions(auth: AuthId, vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
-    if (!auth.userId) throw new WERR_UNAUTHORIZED()
-    return await listActionsIdb(this, auth, vargs)
-  }
-
-  async listOutputs(auth: AuthId, vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
-    if (!auth.userId) throw new WERR_UNAUTHORIZED()
-    return await listOutputsIdb(this, auth, vargs)
-  }
-
-  async countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {
-    const txStatus: TransactionStatus[] = ['completed', 'unproven']
-    if (!excludeSending) txStatus.push('sending')
-    const args: FindOutputsArgs = { partial: { userId, basketId }, txStatus }
-    let count = 0
-    await this.filterOutputs(args, r => {
-      count++
-    })
-    return count
-  }
-
-  async findCertificatesAuth(auth: AuthId, args: FindCertificatesArgs): Promise<TableCertificateX[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new WERR_UNAUTHORIZED()
-    args.partial.userId = auth.userId
-    return await this.findCertificates(args)
-  }
-  async findOutputBasketsAuth(auth: AuthId, args: FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new WERR_UNAUTHORIZED()
-    args.partial.userId = auth.userId
-    return await this.findOutputBaskets(args)
-  }
-  async findOutputsAuth(auth: AuthId, args: FindOutputsArgs): Promise<TableOutput[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new WERR_UNAUTHORIZED()
-    args.partial.userId = auth.userId
-    return await this.findOutputs(args)
-  }
-
-  async insertCertificateAuth(auth: AuthId, certificate: TableCertificateX): Promise<number> {
-    if (!auth.userId || (certificate.userId && certificate.userId !== auth.userId)) throw new WERR_UNAUTHORIZED()
-    certificate.userId = auth.userId
-    return await this.insertCertificate(certificate)
-  }
-
-  //
-  // StorageReaderWriter abstract methods
-  //
-
-  async dropAllData(): Promise<void> {
-    await deleteDB(this.dbName)
-  }
-
-  async filterOutputTagMaps(
-    args: FindOutputTagMapsArgs,
-    filtered: (v: TableOutputTagMap) => void,
-    userId?: number
-  ): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['output_tags_map'], 'readonly', args.trx)
-    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)
-    } else if (args.partial?.outputId !== undefined) {
-      cursor = await dbTrx.objectStore('output_tags_map').index('outputId').openCursor(args.partial.outputId)
-    } else {
-      cursor = await dbTrx.objectStore('output_tags_map').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.tagIds && !args.tagIds.includes(r.outputTagId)) continue
-      if (args.partial) {
-        if (args.partial.outputTagId && r.outputTagId !== args.partial.outputTagId) continue
-        if (args.partial.outputId && r.outputId !== args.partial.outputId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        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 (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findOutputTagMaps(args: FindOutputTagMapsArgs): Promise<TableOutputTagMap[]> {
-    const results: TableOutputTagMap[] = []
-    await this.filterOutputTagMaps(args, r => {
-      results.push(this.validateEntity(r))
-    })
-    return results
-  }
-
-  async filterProvenTxReqs(
-    args: FindProvenTxReqsArgs,
-    filtered: (v: TableProvenTxReq) => void,
-    userId?: number
-  ): Promise<void> {
-    if (args.partial.rawTx)
-      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. ProvenTxReqs may not be found by rawTx value.`)
-    if (args.partial.inputBEEF)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.inputBEEF',
-        `undefined. ProvenTxReqs may not be found by inputBEEF value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['proven_tx_reqs'], 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', 'provenTxId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', 'txid', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'proven_tx_reqs', 'status', 'readwrite' | 'readonly'>
-      | 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)
-    } else if (args.partial?.provenTxId !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('provenTxId').openCursor(args.partial.provenTxId)
-    } else if (args.partial?.txid !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('txid').openCursor(args.partial.txid)
-    } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('status').openCursor(args.partial.status)
-    } else if (args.partial?.batch !== undefined) {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').index('batch').openCursor(args.partial.batch)
-    } else {
-      cursor = await dbTrx.objectStore('proven_tx_reqs').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.provenTxReqId && r.provenTxReqId !== args.partial.provenTxReqId) continue
-        if (args.partial.provenTxId && r.provenTxId !== args.partial.provenTxId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.status && r.status !== args.partial.status) continue
-        if (args.partial.attempts !== undefined && r.attempts !== args.partial.attempts) continue
-        if (args.partial.notified !== undefined && r.notified !== args.partial.notified) continue
-        if (args.partial.txid && r.txid !== args.partial.txid) continue
-        if (args.partial.batch && r.batch !== args.partial.batch) continue
-        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 (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]> {
-    const results: TableProvenTxReq[] = []
-    await this.filterProvenTxReqs(args, r => {
-      results.push(this.validateEntity(r))
-    })
-    return results
-  }
-
-  async filterProvenTxs(args: FindProvenTxsArgs, filtered: (v: TableProvenTx) => void, userId?: number): Promise<void> {
-    if (args.partial.rawTx)
-      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. ProvenTxs may not be found by rawTx value.`)
-    if (args.partial.merklePath)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.merklePath',
-        `undefined. ProvenTxs may not be found by merklePath value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['proven_txs'], 'readonly', args.trx)
-    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)
-    } else if (args.partial?.txid !== undefined) {
-      cursor = await dbTrx.objectStore('proven_txs').index('txid').openCursor(args.partial.txid)
-    } else {
-      cursor = await dbTrx.objectStore('proven_txs').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.provenTxId && r.provenTxId !== args.partial.provenTxId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.txid && r.txid !== args.partial.txid) continue
-        if (args.partial.height !== undefined && r.height !== args.partial.height) continue
-        if (args.partial.index !== undefined && r.index !== args.partial.index) continue
-        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 (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findProvenTxs(args: FindProvenTxsArgs): Promise<TableProvenTx[]> {
-    const results: TableProvenTx[] = []
-    await this.filterProvenTxs(args, r => {
-      results.push(this.validateEntity(r))
-    })
-    return results
-  }
-
-  async filterTxLabelMaps(
-    args: FindTxLabelMapsArgs,
-    filtered: (v: TableTxLabelMap) => void,
-    userId?: number
-  ): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['tx_labels_map'], 'readonly', args.trx)
-    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)
-    } else if (args.partial?.txLabelId !== undefined) {
-      cursor = await dbTrx.objectStore('tx_labels_map').index('txLabelId').openCursor(args.partial.txLabelId)
-    } else {
-      cursor = await dbTrx.objectStore('tx_labels_map').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.txLabelId && r.txLabelId !== args.partial.txLabelId) continue
-        if (args.partial.transactionId && r.transactionId !== args.partial.transactionId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        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 (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findTxLabelMaps(args: FindTxLabelMapsArgs): Promise<TableTxLabelMap[]> {
-    const results: TableTxLabelMap[] = []
-    await this.filterTxLabelMaps(args, r => {
-      results.push(this.validateEntity(r))
-    })
-    return results
-  }
-
-  async countOutputTagMaps(args: FindOutputTagMapsArgs): Promise<number> {
-    let count = 0
-    await this.filterOutputTagMaps(args, () => {
-      count++
-    })
-    return count
-  }
-  async countProvenTxReqs(args: FindProvenTxReqsArgs): Promise<number> {
-    let count = 0
-    await this.filterProvenTxReqs(args, () => {
-      count++
-    })
-    return count
-  }
-  async countProvenTxs(args: FindProvenTxsArgs): Promise<number> {
-    let count = 0
-    await this.filterProvenTxs(args, () => {
-      count++
-    })
-    return count
-  }
-  async countTxLabelMaps(args: FindTxLabelMapsArgs): Promise<number> {
-    let count = 0
-    await this.filterTxLabelMaps(args, () => {
-      count++
-    })
-    return count
-  }
-
-  async insertCertificate(certificate: TableCertificateX, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(certificate, trx, undefined, ['isDeleted'])
-    const fields = e.fields
-    if (e.fields) delete e.fields
-    if (e.certificateId === 0) delete e.certificateId
-
-    const dbTrx = this.toDbTrx(['certificates', 'certificate_fields'], 'readwrite', trx)
-    const store = dbTrx.objectStore('certificates')
-    try {
-      const id = Number(await store.add!(e))
-      certificate.certificateId = id
-
-      if (fields) {
-        for (const field of fields) {
-          field.certificateId = certificate.certificateId
-          field.userId = certificate.userId
-          await this.insertCertificateField(field, dbTrx)
-        }
-      }
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return certificate.certificateId
-  }
-
-  async insertCertificateField(certificateField: TableCertificateField, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(certificateField, trx)
-    const dbTrx = this.toDbTrx(['certificate_fields'], 'readwrite', trx)
-    const store = dbTrx.objectStore('certificate_fields')
-    try {
-      await store.add!(e)
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-  }
-
-  async insertCommission(commission: TableCommission, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(commission, trx)
-    if (e.commissionId === 0) delete e.commissionId
-    const dbTrx = this.toDbTrx(['commissions'], 'readwrite', trx)
-    const store = dbTrx.objectStore('commissions')
-    try {
-      const id = Number(await store.add!(e))
-      commission.commissionId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return commission.commissionId
-  }
-  async insertMonitorEvent(event: TableMonitorEvent, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(event, trx)
-    if (e.id === 0) delete e.id
-    const dbTrx = this.toDbTrx(['monitor_events'], 'readwrite', trx)
-    const store = dbTrx.objectStore('monitor_events')
-    try {
-      const id = Number(await store.add!(e))
-      event.id = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return event.id
-  }
-  async insertOutput(output: TableOutput, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(output, trx)
-    if (e.outputId === 0) delete e.outputId
-    const dbTrx = this.toDbTrx(['outputs'], 'readwrite', trx)
-    const store = dbTrx.objectStore('outputs')
-    try {
-      const id = Number(await store.add!(e))
-      output.outputId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return output.outputId
-  }
-  async insertOutputBasket(basket: TableOutputBasket, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(basket, trx, undefined, ['isDeleted'])
-    if (e.basketId === 0) delete e.basketId
-    const dbTrx = this.toDbTrx(['output_baskets'], 'readwrite', trx)
-    const store = dbTrx.objectStore('output_baskets')
-    try {
-      const id = Number(await store.add!(e))
-      basket.basketId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return basket.basketId
-  }
-  async insertOutputTag(tag: TableOutputTag, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tag, trx, undefined, ['isDeleted'])
-    if (e.outputTagId === 0) delete e.outputTagId
-    const dbTrx = this.toDbTrx(['output_tags'], 'readwrite', trx)
-    const store = dbTrx.objectStore('output_tags')
-    try {
-      const id = Number(await store.add!(e))
-      tag.outputTagId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return tag.outputTagId
-  }
-  async insertOutputTagMap(tagMap: TableOutputTagMap, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(tagMap, trx, undefined, ['isDeleted'])
-    const dbTrx = this.toDbTrx(['output_tags_map'], 'readwrite', trx)
-    const store = dbTrx.objectStore('output_tags_map')
-    try {
-      await store.add!(e)
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-  }
-  async insertProvenTx(tx: TableProvenTx, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.provenTxId === 0) delete e.provenTxId
-    const dbTrx = this.toDbTrx(['proven_txs'], 'readwrite', trx)
-    const store = dbTrx.objectStore('proven_txs')
-    try {
-      const id = Number(await store.add!(e))
-      tx.provenTxId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return tx.provenTxId
-  }
-  async insertProvenTxReq(tx: TableProvenTxReq, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.provenTxReqId === 0) delete e.provenTxReqId
-    const dbTrx = this.toDbTrx(['proven_tx_reqs'], 'readwrite', trx)
-    const store = dbTrx.objectStore('proven_tx_reqs')
-    try {
-      const id = Number(await store.add!(e))
-      tx.provenTxReqId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return tx.provenTxReqId
-  }
-  async insertSyncState(syncState: TableSyncState, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(syncState, trx, ['when'], ['init'])
-    if (e.syncStateId === 0) delete e.syncStateId
-    const dbTrx = this.toDbTrx(['sync_states'], 'readwrite', trx)
-    const store = dbTrx.objectStore('sync_states')
-    try {
-      const id = Number(await store.add!(e))
-      syncState.syncStateId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return syncState.syncStateId
-  }
-  async insertTransaction(tx: TableTransaction, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.transactionId === 0) delete e.transactionId
-    const dbTrx = this.toDbTrx(['transactions'], 'readwrite', trx)
-    const store = dbTrx.objectStore('transactions')
-    try {
-      const id = Number(await store.add!(e))
-      tx.transactionId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return tx.transactionId
-  }
-  async insertTxLabel(label: TableTxLabel, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(label, trx, undefined, ['isDeleted'])
-    if (e.txLabelId === 0) delete e.txLabelId
-    const dbTrx = this.toDbTrx(['tx_labels'], 'readwrite', trx)
-    const store = dbTrx.objectStore('tx_labels')
-    try {
-      const id = Number(await store.add!(e))
-      label.txLabelId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return label.txLabelId
-  }
-  async insertTxLabelMap(labelMap: TableTxLabelMap, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(labelMap, trx, undefined, ['isDeleted'])
-    const dbTrx = this.toDbTrx(['tx_labels_map'], 'readwrite', trx)
-    const store = dbTrx.objectStore('tx_labels_map')
-    try {
-      await store.add!(e)
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-  }
-  async insertUser(user: TableUser, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(user, trx)
-    if (e.userId === 0) delete e.userId
-    const dbTrx = this.toDbTrx(['users'], 'readwrite', trx)
-    const store = dbTrx.objectStore('users')
-    try {
-      const id = Number(await store.add!(e))
-      user.userId = id
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return user.userId
-  }
-
-  async updateIdb<T>(
-    id: number | number[],
-    update: Partial<T>,
-    keyProp: string,
-    storeName: string,
-    trx?: TrxToken
-  ): Promise<number> {
-    if (update[keyProp] !== undefined && (Array.isArray(id) || update[keyProp] !== id)) {
-      throw new WERR_INVALID_PARAMETER(`update.${keyProp}`, `undefined`)
-    }
-    const u = this.validatePartialForUpdate(update)
-    const dbTrx = this.toDbTrx([storeName], 'readwrite', trx)
-    const store = dbTrx.objectStore(storeName)
-    const ids = Array.isArray(id) ? id : [id]
-    try {
-      for (const i of ids) {
-        const e = await store.get(i)
-        if (!e) throw new WERR_INVALID_PARAMETER('id', `an existing record to update ${keyProp} ${i} not found`)
-        const v: T = {
-          ...e,
-          ...u
-        }
-        const uid = await store.put!(v)
-        if (uid !== i) throw new WERR_INTERNAL(`updated id ${uid} does not match original ${id}`)
-      }
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-    return 1
-  }
-
-  async updateIdbKey<T>(
-    key: (number | string)[],
-    update: Partial<T>,
-    keyProps: string[],
-    storeName: string,
-    trx?: TrxToken
-  ): Promise<number> {
-    if (key.length !== keyProps.length)
-      throw new WERR_INTERNAL(`key.length ${key.length} !== keyProps.length ${keyProps.length}`)
-    for (let i = 0; i < key.length; i++) {
-      if (update[keyProps[i]] !== undefined && update[keyProps[i]] !== key[i]) {
-        throw new WERR_INVALID_PARAMETER(`update.${keyProps[i]}`, `undefined`)
-      }
-    }
-    const u = this.validatePartialForUpdate(update)
-    const dbTrx = this.toDbTrx([storeName], 'readwrite', trx)
-    const store = dbTrx.objectStore(storeName)
-    try {
-      const e = await store.get(key)
-      if (!e)
-        throw new WERR_INVALID_PARAMETER(
-          'key',
-          `an existing record to update ${keyProps.join(',')} ${key.join(',')} not found`
-        )
-      const v: T = {
-        ...e,
-        ...u
-      }
-      const uid = await store.put!(v)
-      for (let i = 0; i < key.length; i++) {
-        if (uid[i] !== key[i]) throw new WERR_INTERNAL(`updated key ${uid[i]} does not match original ${key[i]}`)
-      }
-    } finally {
-      if (!trx) await dbTrx.done
-    }
-
-    return 1
-  }
-
-  async updateCertificate(id: number, update: Partial<TableCertificate>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'certificateId', 'certificates', trx)
-  }
-
-  async updateCertificateField(
-    certificateId: number,
-    fieldName: string,
-    update: Partial<TableCertificateField>,
-    trx?: TrxToken
-  ): Promise<number> {
-    return this.updateIdbKey(
-      [certificateId, fieldName],
-      update,
-      ['certificateId', 'fieldName'],
-      'certificate_fields',
-      trx
-    )
-  }
-
-  async updateCommission(id: number, update: Partial<TableCommission>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'commissionId', 'commissions', trx)
-  }
-  async updateMonitorEvent(id: number, update: Partial<TableMonitorEvent>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'id', 'monitor_events', trx)
-  }
-  async updateOutput(id: number, update: Partial<TableOutput>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'outputId', 'outputs', trx)
-  }
-  async updateOutputBasket(id: number, update: Partial<TableOutputBasket>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'basketId', 'output_baskets', trx)
-  }
-  async updateOutputTag(id: number, update: Partial<TableOutputTag>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'outputTagId', 'output_tags', trx)
-  }
-  async updateProvenTx(id: number, update: Partial<TableProvenTx>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'provenTxId', 'proven_txs', trx)
-  }
-  async updateProvenTxReq(id: number | number[], update: Partial<TableProvenTxReq>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'provenTxReqId', 'proven_tx_reqs', trx)
-  }
-  async updateSyncState(id: number, update: Partial<TableSyncState>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'syncStateId', 'sync_states', trx)
-  }
-  async updateTransaction(id: number | number[], update: Partial<TableTransaction>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'transactionId', 'transactions', trx)
-  }
-  async updateTxLabel(id: number, update: Partial<TableTxLabel>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'txLabelId', 'tx_labels', trx)
-  }
-  async updateUser(id: number, update: Partial<TableUser>, trx?: TrxToken): Promise<number> {
-    return this.updateIdb(id, update, 'userId', 'users', trx)
-  }
-  async updateOutputTagMap(
-    outputId: number,
-    tagId: number,
-    update: Partial<TableOutputTagMap>,
-    trx?: TrxToken
-  ): Promise<number> {
-    return this.updateIdbKey([tagId, outputId], update, ['outputTagId', 'outputId'], 'output_tags_map', trx)
-  }
-  async updateTxLabelMap(
-    transactionId: number,
-    txLabelId: number,
-    update: Partial<TableTxLabelMap>,
-    trx?: TrxToken
-  ): Promise<number> {
-    return this.updateIdbKey([txLabelId, transactionId], update, ['txLabelId', 'transactionId'], 'tx_labels_map', trx)
-  }
-
-  //
-  // StorageReader abstract methods
-  //
-
-  async destroy(): Promise<void> {
-    if (this.db) {
-      this.db.close()
-    }
-    this.db = undefined
-    this._settings = undefined
-  }
-
-  allStores: string[] = [
-    'certificates',
-    'certificate_fields',
-    'commissions',
-    'monitor_events',
-    'outputs',
-    'output_baskets',
-    'output_tags',
-    'output_tags_map',
-    'proven_txs',
-    'proven_tx_reqs',
-    'sync_states',
-    'transactions',
-    'tx_labels',
-    'tx_labels_map',
-    'users'
-  ]
-
-  /**
-   * @param scope
-   * @param trx
-   * @returns
-   */
-  async transaction<T>(scope: (trx: TrxToken) => Promise<T>, trx?: TrxToken): Promise<T> {
-    if (trx) return await scope(trx)
-
-    const stores = this.allStores
-
-    const db = await this.verifyDB()
-    const tx = db.transaction(stores, 'readwrite')
-
-    try {
-      const r = await scope(tx as TrxToken)
-      await tx.done
-      return r
-    } catch (err) {
-      tx.abort()
-      await tx.done
-      throw err
-    }
-  }
-
-  async filterCertificateFields(
-    args: FindCertificateFieldsArgs,
-    filtered: (v: TableCertificateField) => void
-  ): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['certificate_fields'], 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificate_fields', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificate_fields', 'userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificate_fields', 'certificateId', 'readwrite' | 'readonly'>
-      | null
-    if (args.partial?.certificateId !== undefined) {
-      cursor = await dbTrx
-        .objectStore('certificate_fields')
-        .index('certificateId')
-        .openCursor(args.partial.certificateId)
-    } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('certificate_fields').index('userId').openCursor(args.partial.userId)
-    } else {
-      cursor = await dbTrx.objectStore('certificate_fields').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.certificateId && r.certificateId !== args.partial.certificateId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.fieldName && r.fieldName !== args.partial.fieldName) continue
-        if (args.partial.fieldValue && r.fieldValue !== args.partial.fieldValue) continue
-        if (args.partial.masterKey && r.masterKey !== args.partial.masterKey) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findCertificateFields(args: FindCertificateFieldsArgs): Promise<TableCertificateField[]> {
-    const result: TableCertificateField[] = []
-    await this.filterCertificateFields(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterCertificates(args: FindCertificatesArgs, filtered: (v: TableCertificateX) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['certificates'], 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificates', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'certificates', 'userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<
-          StorageIdbSchema,
-          string[],
-          'certificates',
-          'userId_type_certifier_serialNumber',
-          'readwrite' | 'readonly'
-        >
-      | null
-    if (args.partial?.certificateId) {
-      cursor = await dbTrx.objectStore('certificates').openCursor(args.partial.certificateId)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('certificates').index('userId').openCursor(args.partial.userId)
-      }
-    } else {
-      cursor = await dbTrx.objectStore('certificates').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.certifiers && !args.certifiers.includes(r.certifier)) continue
-      if (args.types && !args.types.includes(r.type)) continue
-      if (args.partial) {
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.certificateId && r.certificateId !== args.partial.certificateId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.type && r.type !== args.partial.type) continue
-        if (args.partial.serialNumber && r.serialNumber !== args.partial.serialNumber) continue
-        if (args.partial.certifier && r.certifier !== args.partial.certifier) continue
-        if (args.partial.subject && r.subject !== args.partial.subject) continue
-        if (args.partial.verifier && r.verifier !== args.partial.verifier) continue
-        if (args.partial.revocationOutpoint && r.revocationOutpoint !== args.partial.revocationOutpoint) continue
-        if (args.partial.signature && r.signature !== args.partial.signature) continue
-        if (args.partial.isDeleted && r.isDeleted !== args.partial.isDeleted) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findCertificates(args: FindCertificatesArgs): Promise<TableCertificateX[]> {
-    const result: TableCertificateX[] = []
-    await this.filterCertificates(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    if (args.includeFields) {
-      for (const c of result) {
-        const fields = await this.findCertificateFields({ partial: { certificateId: c.certificateId }, trx: args.trx })
-        c.fields = fields
-      }
-    }
-    return result
-  }
-
-  async filterCommissions(args: FindCommissionsArgs, filtered: (v: TableCommission) => void): Promise<void> {
-    if (args.partial.lockingScript)
-      throw new WERR_INVALID_PARAMETER(
-        'partial.lockingScript',
-        `undefined. Commissions may not be found by lockingScript value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['commissions'], 'readonly', args.trx)
-    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)
-    } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('commissions').index('userId').openCursor(args.partial.userId)
-    } else if (args.partial?.transactionId !== undefined) {
-      cursor = await dbTrx.objectStore('commissions').index('transactionId').openCursor(args.partial.transactionId)
-    } else {
-      cursor = await dbTrx.objectStore('commissions').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.commissionId && r.commissionId !== args.partial.commissionId) continue
-        if (args.partial.transactionId && r.transactionId !== args.partial.transactionId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.satoshis !== undefined && r.satoshis !== args.partial.satoshis) continue
-        if (args.partial.keyOffset && r.keyOffset !== args.partial.keyOffset) continue
-        if (args.partial.isRedeemed !== undefined && r.isRedeemed !== args.partial.isRedeemed) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findCommissions(args: FindCommissionsArgs): Promise<TableCommission[]> {
-    const result: TableCommission[] = []
-    await this.filterCommissions(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterMonitorEvents(args: FindMonitorEventsArgs, filtered: (v: TableMonitorEvent) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['monitor_events'], 'readonly', args.trx)
-    let cursor: IDBPCursorWithValue<
-      StorageIdbSchema,
-      string[],
-      'monitor_events',
-      unknown,
-      'readwrite' | 'readonly'
-    > | null
-    if (args.partial?.id) {
-      cursor = await dbTrx.objectStore('monitor_events').openCursor(args.partial.id)
-    } else {
-      cursor = await dbTrx.objectStore('monitor_events').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.id && r.id !== args.partial.id) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.event && r.event !== args.partial.event) continue
-        if (args.partial.details && r.details !== args.partial.details) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findMonitorEvents(args: FindMonitorEventsArgs): Promise<TableMonitorEvent[]> {
-    const result: TableMonitorEvent[] = []
-    await this.filterMonitorEvents(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterOutputBaskets(args: FindOutputBasketsArgs, filtered: (v: TableOutputBasket) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['output_baskets'], 'readonly', args.trx)
-    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)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('output_baskets').index('userId').openCursor(args.partial.userId)
-      }
-    } else {
-      cursor = await dbTrx.objectStore('output_baskets').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.basketId && r.basketId !== args.partial.basketId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.name && r.name !== args.partial.name) continue
-        if (
-          args.partial.numberOfDesiredUTXOs !== undefined &&
-          r.numberOfDesiredUTXOs !== args.partial.numberOfDesiredUTXOs
-        )
-          continue
-        if (
-          args.partial.minimumDesiredUTXOValue !== undefined &&
-          r.numberOfDesiredSatoshis !== args.partial.minimumDesiredUTXOValue
-        )
-          continue
-        if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findOutputBaskets(args: FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
-    const result: TableOutputBasket[] = []
-    await this.filterOutputBaskets(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterOutputs(
-    args: FindOutputsArgs,
-    filtered: (v: TableOutput) => void,
-    tagIds?: number[],
-    isQueryModeAll?: boolean
-  ): Promise<void> {
-    // args.txStatus
-    // args.noScript
-    if (args.partial.lockingScript)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.lockingScript',
-        `undefined. Outputs may not be found by lockingScript value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const stores = ['outputs']
-    if (tagIds && tagIds.length > 0) {
-      stores.push('output_tags_map')
-    }
-    if (args.txStatus) {
-      stores.push('transactions')
-    }
-    const dbTrx = this.toDbTrx(stores, 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<
-          StorageIdbSchema,
-          string[],
-          'outputs',
-          'transactionId_vout_userId',
-          'readwrite' | 'readonly'
-        >
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'transactionId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'basketId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'outputs', 'spentBy', 'readwrite' | 'readonly'>
-      | null
-    if (args.partial?.outputId) {
-      cursor = await dbTrx.objectStore('outputs').openCursor(args.partial.outputId)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('outputs').index('userId').openCursor(args.partial.userId)
-      }
-    } else if (args.partial?.transactionId !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('transactionId').openCursor(args.partial.transactionId)
-    } else if (args.partial?.basketId !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('basketId').openCursor(args.partial.basketId)
-    } else if (args.partial?.spentBy !== undefined) {
-      cursor = await dbTrx.objectStore('outputs').index('spentBy').openCursor(args.partial.spentBy)
-    } else {
-      cursor = await dbTrx.objectStore('outputs').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.outputId && r.outputId !== args.partial.outputId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.transactionId && r.transactionId !== args.partial.transactionId) continue
-        if (args.partial.basketId && r.basketId !== args.partial.basketId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.spendable !== undefined && r.spendable !== args.partial.spendable) continue
-        if (args.partial.change !== undefined && r.change !== args.partial.change) continue
-        if (args.partial.outputDescription && r.outputDescription !== args.partial.outputDescription) continue
-        if (args.partial.vout !== undefined && r.vout !== args.partial.vout) continue
-        if (args.partial.satoshis !== undefined && r.satoshis !== args.partial.satoshis) continue
-        if (args.partial.providedBy && r.providedBy !== args.partial.providedBy) continue
-        if (args.partial.purpose && r.purpose !== args.partial.purpose) continue
-        if (args.partial.type && r.type !== args.partial.type) continue
-        if (args.partial.txid && r.txid !== args.partial.txid) continue
-        if (args.partial.senderIdentityKey && r.senderIdentityKey !== args.partial.senderIdentityKey) continue
-        if (args.partial.derivationPrefix && r.derivationPrefix !== args.partial.derivationPrefix) continue
-        if (args.partial.derivationSuffix && r.derivationSuffix !== args.partial.derivationSuffix) continue
-        if (args.partial.customInstructions && r.customInstructions !== args.partial.customInstructions) continue
-        if (args.partial.spentBy && r.spentBy !== args.partial.spentBy) continue
-        if (args.partial.sequenceNumber !== undefined && r.sequenceNumber !== args.partial.sequenceNumber) continue
-        if (args.partial.scriptLength !== undefined && r.scriptLength !== args.partial.scriptLength) continue
-        if (args.partial.scriptOffset !== undefined && r.scriptOffset !== args.partial.scriptOffset) continue
-      }
-      if (args.txStatus !== undefined) {
-        const count = await this.countTransactions({
-          partial: { transactionId: r.transactionId },
-          status: args.txStatus,
-          trx: dbTrx
-        })
-        if (count === 0) continue
-      }
-      if (tagIds && tagIds.length > 0) {
-        let ids = [...tagIds]
-        await this.filterOutputTagMaps({ partial: { outputId: r.outputId }, trx: dbTrx }, tm => {
-          if (ids.length > 0) {
-            const i = ids.indexOf(tm.outputTagId)
-            if (i >= 0) {
-              if (isQueryModeAll) {
-                ids.splice(i, 1)
-              } else {
-                ids = []
-              }
-            }
-          }
-        })
-        if (ids.length > 0) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      if (args.noScript === true) {
-        r.script = undefined
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findOutputs(args: FindOutputsArgs, tagIds?: number[], isQueryModeAll?: boolean): Promise<TableOutput[]> {
-    const results: TableOutput[] = []
-    await this.filterOutputs(
-      args,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      tagIds,
-      isQueryModeAll
-    )
-    for (const o of results) {
-      if (!args.noScript) {
-        await this.validateOutputScript(o)
-      } else {
-        o.lockingScript = undefined
-      }
-    }
-    return results
-  }
-
-  async filterOutputTags(args: FindOutputTagsArgs, filtered: (v: TableOutputTag) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['output_tags'], 'readonly', args.trx)
-    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)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('output_tags').index('userId').openCursor(args.partial.userId)
-      }
-    } else {
-      cursor = await dbTrx.objectStore('output_tags').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.outputTagId && r.outputTagId !== args.partial.outputTagId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.tag && r.tag !== args.partial.tag) continue
-        if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findOutputTags(args: FindOutputTagsArgs): Promise<TableOutputTag[]> {
-    const result: TableOutputTag[] = []
-    await this.filterOutputTags(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterSyncStates(args: FindSyncStatesArgs, filtered: (v: TableSyncState) => void): Promise<void> {
-    if (args.partial.syncMap)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.syncMap',
-        `undefined. SyncStates may not be found by syncMap value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['sync_states'], 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', 'userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', 'refNum', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'sync_states', 'status', 'readwrite' | 'readonly'>
-      | null
-    if (args.partial?.syncStateId) {
-      cursor = await dbTrx.objectStore('sync_states').openCursor(args.partial.syncStateId)
-    } else if (args.partial?.userId !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('userId').openCursor(args.partial.userId)
-    } else if (args.partial?.refNum !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('refNum').openCursor(args.partial.refNum)
-    } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('sync_states').index('status').openCursor(args.partial.status)
-    } else {
-      cursor = await dbTrx.objectStore('sync_states').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.syncStateId && r.syncStateId !== args.partial.syncStateId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.storageIdentityKey && r.storageIdentityKey !== args.partial.storageIdentityKey) continue
-        if (args.partial.storageName && r.storageName !== args.partial.storageName) continue
-        if (args.partial.status && r.status !== args.partial.status) continue
-        if (args.partial.init !== undefined && r.init !== args.partial.init) continue
-        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.errorOther && r.errorOther !== args.partial.errorOther) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findSyncStates(args: FindSyncStatesArgs): Promise<TableSyncState[]> {
-    const result: TableSyncState[] = []
-    await this.filterSyncStates(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterTransactions(
-    args: FindTransactionsArgs,
-    filtered: (v: TableTransaction) => void,
-    labelIds?: number[],
-    isQueryModeAll?: boolean
-  ): Promise<void> {
-    if (args.partial.rawTx)
-      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. Transactions may not be found by rawTx value.`)
-    if (args.partial.inputBEEF)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.inputBEEF',
-        `undefined. Transactions may not be found by inputBEEF value.`
-      )
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const stores = ['transactions']
-    if (labelIds && labelIds.length > 0) {
-      stores.push('tx_labels_map')
-    }
-    const dbTrx = this.toDbTrx(stores, 'readonly', args.trx)
-    let cursor:
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', unknown, 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'status', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'status_userId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'provenTxId', 'readwrite' | 'readonly'>
-      | IDBPCursorWithValue<StorageIdbSchema, string[], 'transactions', 'reference', 'readwrite' | 'readonly'>
-      | null
-    if (args.partial?.transactionId) {
-      cursor = await dbTrx.objectStore('transactions').openCursor(args.partial.transactionId)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('transactions').index('userId').openCursor(args.partial.userId)
-      }
-    } else if (args.partial?.status !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('status').openCursor(args.partial.status)
-    } else if (args.partial?.provenTxId !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('provenTxId').openCursor(args.partial.provenTxId)
-    } else if (args.partial?.reference !== undefined) {
-      cursor = await dbTrx.objectStore('transactions').index('reference').openCursor(args.partial.reference)
-    } else {
-      cursor = await dbTrx.objectStore('transactions').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.status && !args.status.includes(r.status)) continue
-      if (args.partial) {
-        if (args.partial.transactionId && r.transactionId !== args.partial.transactionId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.provenTxId && r.provenTxId !== args.partial.provenTxId) continue
-        if (args.partial.status && r.status !== args.partial.status) continue
-        if (args.partial.reference && r.reference !== args.partial.reference) continue
-        if (args.partial.isOutgoing !== undefined && r.isOutgoing !== args.partial.isOutgoing) continue
-        if (args.partial.satoshis !== undefined && r.satoshis !== args.partial.satoshis) continue
-        if (args.partial.description && r.description !== args.partial.description) continue
-        if (args.partial.version !== undefined && r.version !== args.partial.version) continue
-        if (args.partial.lockTime !== undefined && r.lockTime !== args.partial.lockTime) continue
-        if (args.partial.txid && r.txid !== args.partial.txid) continue
-      }
-      if (labelIds && labelIds.length > 0) {
-        let ids = [...labelIds]
-        await this.filterTxLabelMaps({ partial: { transactionId: r.transactionId }, trx: dbTrx }, lm => {
-          if (ids.length > 0) {
-            const i = ids.indexOf(lm.txLabelId)
-            if (i >= 0) {
-              if (isQueryModeAll) {
-                ids.splice(i, 1)
-              } else {
-                ids = []
-              }
-            }
-          }
-        })
-        if (ids.length > 0) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findTransactions(
-    args: FindTransactionsArgs,
-    labelIds?: number[],
-    isQueryModeAll?: boolean
-  ): Promise<TableTransaction[]> {
-    const results: TableTransaction[] = []
-    await this.filterTransactions(
-      args,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      labelIds,
-      isQueryModeAll
-    )
-    for (const t of results) {
-      if (!args.noRawTx) {
-        await this.validateRawTransaction(t, args.trx)
-      } else {
-        t.rawTx = undefined
-        t.inputBEEF = undefined
-      }
-    }
-    return results
-  }
-
-  async filterTxLabels(args: FindTxLabelsArgs, filtered: (v: TableTxLabel) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['tx_labels'], 'readonly', args.trx)
-    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)
-    } 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])
-      } else {
-        cursor = await dbTrx.objectStore('tx_labels').index('userId').openCursor(args.partial.userId)
-      }
-    } else {
-      cursor = await dbTrx.objectStore('tx_labels').openCursor()
-    }
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.txLabelId && r.txLabelId !== args.partial.txLabelId) continue
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.label && r.label !== args.partial.label) continue
-        if (args.partial.isDeleted !== undefined && r.isDeleted !== args.partial.isDeleted) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findTxLabels(args: FindTxLabelsArgs): Promise<TableTxLabel[]> {
-    const result: TableTxLabel[] = []
-    await this.filterTxLabels(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async filterUsers(args: FindUsersArgs, filtered: (v: TableUser) => void): Promise<void> {
-    const offset = args.paged?.offset || 0
-    let skipped = 0
-    let count = 0
-    const dbTrx = this.toDbTrx(['users'], 'readonly', args.trx)
-    let cursor = await dbTrx.objectStore('users').openCursor()
-    let firstTime = true
-    while (cursor) {
-      if (!firstTime) cursor = await cursor.continue()
-      if (!cursor) break
-      firstTime = false
-      const r = cursor.value
-      if (args.since && args.since > r.updated_at) continue
-      if (args.partial) {
-        if (args.partial.userId && r.userId !== args.partial.userId) continue
-        if (args.partial.created_at && r.created_at.getTime() !== args.partial.created_at.getTime()) continue
-        if (args.partial.updated_at && r.updated_at.getTime() !== args.partial.updated_at.getTime()) continue
-        if (args.partial.identityKey && r.identityKey !== args.partial.identityKey) continue
-        if (args.partial.activeStorage && r.activeStorage !== args.partial.activeStorage) continue
-      }
-      if (skipped < offset) {
-        skipped++
-        continue
-      }
-      filtered(r)
-      count++
-      if (args.paged?.limit && count >= args.paged.limit) break
-    }
-    if (!args.trx) await dbTrx.done
-  }
-
-  async findUsers(args: FindUsersArgs): Promise<TableUser[]> {
-    const result: TableUser[] = []
-    await this.filterUsers(args, r => {
-      result.push(this.validateEntity(r))
-    })
-    return result
-  }
-
-  async countCertificateFields(args: FindCertificateFieldsArgs): Promise<number> {
-    let count = 0
-    await this.filterCertificateFields(args, () => {
-      count++
-    })
-    return count
-  }
-  async countCertificates(args: FindCertificatesArgs): Promise<number> {
-    let count = 0
-    await this.filterCertificates(args, () => {
-      count++
-    })
-    return count
-  }
-  async countCommissions(args: FindCommissionsArgs): Promise<number> {
-    let count = 0
-    await this.filterCommissions(args, () => {
-      count++
-    })
-    return count
-  }
-  async countMonitorEvents(args: FindMonitorEventsArgs): Promise<number> {
-    let count = 0
-    await this.filterMonitorEvents(args, () => {
-      count++
-    })
-    return count
-  }
-  async countOutputBaskets(args: FindOutputBasketsArgs): Promise<number> {
-    let count = 0
-    await this.filterOutputBaskets(args, () => {
-      count++
-    })
-    return count
-  }
-  async countOutputs(args: FindOutputsArgs, tagIds?: number[], isQueryModeAll?: boolean): Promise<number> {
-    let count = 0
-    await this.filterOutputs(
-      { ...args, noScript: true },
-      () => {
-        count++
-      },
-      tagIds,
-      isQueryModeAll
-    )
-    return count
-  }
-  async countOutputTags(args: FindOutputTagsArgs): Promise<number> {
-    let count = 0
-    await this.filterOutputTags(args, () => {
-      count++
-    })
-    return count
-  }
-  async countSyncStates(args: FindSyncStatesArgs): Promise<number> {
-    let count = 0
-    await this.filterSyncStates(args, () => {
-      count++
-    })
-    return count
-  }
-  async countTransactions(args: FindTransactionsArgs, labelIds?: number[], isQueryModeAll?: boolean): Promise<number> {
-    let count = 0
-    await this.filterTransactions(
-      { ...args, noRawTx: true },
-      () => {
-        count++
-      },
-      labelIds,
-      isQueryModeAll
-    )
-    return count
-  }
-  async countTxLabels(args: FindTxLabelsArgs): Promise<number> {
-    let count = 0
-    await this.filterTxLabels(args, () => {
-      count++
-    })
-    return count
-  }
-  async countUsers(args: FindUsersArgs): Promise<number> {
-    let count = 0
-    await this.filterUsers(args, () => {
-      count++
-    })
-    return count
-  }
-
-  async getProvenTxsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTx[]> {
-    const results: TableProvenTx[] = []
-    const fargs: FindProvenTxsArgs = {
-      partial: {},
-      since: args.since,
-      paged: args.paged,
-      trx: args.trx
-    }
-    await this.filterProvenTxs(
-      fargs,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      args.userId
-    )
-    return results
-  }
-
-  async getProvenTxReqsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTxReq[]> {
-    const results: TableProvenTxReq[] = []
-    const fargs: FindProvenTxReqsArgs = {
-      partial: {},
-      since: args.since,
-      paged: args.paged,
-      trx: args.trx
-    }
-    await this.filterProvenTxReqs(
-      fargs,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      args.userId
-    )
-    return results
-  }
-
-  async getTxLabelMapsForUser(args: FindForUserSincePagedArgs): Promise<TableTxLabelMap[]> {
-    const results: TableTxLabelMap[] = []
-    const fargs: FindTxLabelMapsArgs = {
-      partial: {},
-      since: args.since,
-      paged: args.paged,
-      trx: args.trx
-    }
-    await this.filterTxLabelMaps(
-      fargs,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      args.userId
-    )
-    return results
-  }
-
-  async getOutputTagMapsForUser(args: FindForUserSincePagedArgs): Promise<TableOutputTagMap[]> {
-    const results: TableOutputTagMap[] = []
-    const fargs: FindOutputTagMapsArgs = {
-      partial: {},
-      since: args.since,
-      paged: args.paged,
-      trx: args.trx
-    }
-    await this.filterOutputTagMaps(
-      fargs,
-      r => {
-        results.push(this.validateEntity(r))
-      },
-      args.userId
-    )
-    return results
-  }
-
-  async verifyReadyForDatabaseAccess(trx?: TrxToken): Promise<DBType> {
-    if (!this._settings) {
-      this._settings = await this.readSettings()
-    }
-
-    return this._settings.dbtype
-  }
-
-  /**
-   * Helper to force uniform behavior across database engines.
-   * Use to process all individual records with time stamps or number[] retreived from database.
-   */
-  validateEntity<T extends EntityTimeStamp>(entity: T, dateFields?: string[], booleanFields?: string[]): T {
-    entity.created_at = this.validateDate(entity.created_at)
-    entity.updated_at = this.validateDate(entity.updated_at)
-    if (dateFields) {
-      for (const df of dateFields) {
-        if (entity[df]) entity[df] = this.validateDate(entity[df])
-      }
-    }
-    if (booleanFields) {
-      for (const df of booleanFields) {
-        if (entity[df] !== undefined) entity[df] = !!entity[df]
-      }
-    }
-    for (const key of Object.keys(entity)) {
-      const val = entity[key]
-      if (val === null) {
-        entity[key] = undefined
-      } else if (val instanceof Uint8Array) {
-        entity[key] = Array.from(val)
-      }
-    }
-    return entity
-  }
-
-  /**
-   * Helper to force uniform behavior across database engines.
-   * Use to process all arrays of records with time stamps retreived from database.
-   * @returns input `entities` array with contained values validated.
-   */
-  validateEntities<T extends EntityTimeStamp>(entities: T[], dateFields?: string[], booleanFields?: string[]): T[] {
-    for (let i = 0; i < entities.length; i++) {
-      entities[i] = this.validateEntity(entities[i], dateFields, booleanFields)
-    }
-    return entities
-  }
-  /**
-   * Helper to force uniform behavior across database engines.
-   * Use to process the update template for entities being updated.
-   */
-  validatePartialForUpdate<T extends EntityTimeStamp>(
-    update: Partial<T>,
-    dateFields?: string[],
-    booleanFields?: string[]
-  ): Partial<T> {
-    if (!this.dbtype) throw new WERR_INTERNAL('must call verifyReadyForDatabaseAccess first')
-    const v: any = { ...update }
-    if (v.created_at) v.created_at = this.validateEntityDate(v.created_at)
-    if (v.updated_at) v.updated_at = this.validateEntityDate(v.updated_at)
-    if (!v.created_at) delete v.created_at
-    if (!v.updated_at) v.updated_at = this.validateEntityDate(new Date())
-
-    if (dateFields) {
-      for (const df of dateFields) {
-        if (v[df]) v[df] = this.validateOptionalEntityDate(v[df])
-      }
-    }
-    if (booleanFields) {
-      for (const df of booleanFields) {
-        if (update[df] !== undefined) update[df] = !!update[df] ? 1 : 0
-      }
-    }
-    for (const key of Object.keys(v)) {
-      const val = v[key]
-      if (Array.isArray(val) && (val.length === 0 || Number.isInteger(val[0]))) {
-        v[key] = Uint8Array.from(val)
-      } else if (val === null) {
-        v[key] = undefined
-      }
-    }
-    this.isDirty = true
-    return v
-  }
-
-  /**
-   * Helper to force uniform behavior across database engines.
-   * Use to process new entities being inserted into the database.
-   */
-  async validateEntityForInsert<T extends EntityTimeStamp>(
-    entity: T,
-    trx?: TrxToken,
-    dateFields?: string[],
-    booleanFields?: string[]
-  ): Promise<any> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    const v: any = { ...entity }
-    v.created_at = this.validateOptionalEntityDate(v.created_at, true)!
-    v.updated_at = this.validateOptionalEntityDate(v.updated_at, true)!
-    if (!v.created_at) delete v.created_at
-    if (!v.updated_at) delete v.updated_at
-    if (dateFields) {
-      for (const df of dateFields) {
-        if (v[df]) v[df] = this.validateOptionalEntityDate(v[df])
-      }
-    }
-    if (booleanFields) {
-      for (const df of booleanFields) {
-        if (entity[df] !== undefined) entity[df] = !!entity[df] ? 1 : 0
-      }
-    }
-    for (const key of Object.keys(v)) {
-      const val = v[key]
-      if (Array.isArray(val) && (val.length === 0 || Number.isInteger(val[0]))) {
-        v[key] = Uint8Array.from(val)
-      } else if (val === null) {
-        v[key] = undefined
-      }
-    }
-    this.isDirty = true
-    return v
-  }
-
-  async validateRawTransaction(t: TableTransaction, trx?: TrxToken): Promise<void> {
-    // if there is no txid or there is a rawTransaction return what we have.
-    if (t.rawTx || !t.txid) return
-
-    // rawTransaction is missing, see if we moved it ...
-
-    const rawTx = await this.getRawTxOfKnownValidTransaction(t.txid, undefined, undefined, trx)
-    if (!rawTx) return
-    t.rawTx = rawTx
-  }
-
-  async adminStats(adminIdentityKey: string): Promise<StorageAdminStats> {
-    throw new Error('Method intentionally not implemented for personal storage.')
-  }
-}