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

package/src/storage/StorageKnex.ts

@@ -1,1425 +0,0 @@
-import { ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
-import {
-  outputColumnsWithoutLockingScript,
-  TableCertificate,
-  TableCertificateField,
-  TableCertificateX,
-  TableCommission,
-  TableMonitorEvent,
-  TableOutput,
-  TableOutputBasket,
-  TableOutputTag,
-  TableOutputTagMap,
-  TableProvenTx,
-  TableProvenTxReq,
-  TableSettings,
-  TableSyncState,
-  TableTransaction,
-  TableTxLabel,
-  TableTxLabelMap,
-  TableUser,
-  transactionColumnsWithoutRawTx
-} from './schema/tables'
-import { KnexMigrations } from './schema/KnexMigrations'
-import { Knex } from 'knex'
-import { AdminStatsResult, StorageProvider, StorageProviderOptions } from './StorageProvider'
-import { purgeData } from './methods/purgeData'
-import { listActions } from './methods/listActionsKnex'
-import { listOutputs } from './methods/listOutputsKnex'
-import { DBType } from './StorageReader'
-import { reviewStatus } from './methods/reviewStatus'
-import { ServicesCallHistory } from '../sdk/WalletServices.interfaces'
-import {
-  AuthId,
-  FindCertificateFieldsArgs,
-  FindCertificatesArgs,
-  FindCommissionsArgs,
-  FindForUserSincePagedArgs,
-  FindMonitorEventsArgs,
-  FindOutputBasketsArgs,
-  FindOutputsArgs,
-  FindOutputTagMapsArgs,
-  FindOutputTagsArgs,
-  FindPartialSincePagedArgs,
-  FindProvenTxReqsArgs,
-  FindProvenTxsArgs,
-  FindSyncStatesArgs,
-  FindTransactionsArgs,
-  FindTxLabelMapsArgs,
-  FindTxLabelsArgs,
-  FindUsersArgs,
-  ProvenOrRawTx,
-  PurgeParams,
-  PurgeResults,
-  TrxToken,
-  WalletStorageProvider
-} from '../sdk/WalletStorage.interfaces'
-import { WERR_INTERNAL, WERR_INVALID_PARAMETER, WERR_NOT_IMPLEMENTED, WERR_UNAUTHORIZED } from '../sdk/WERR_errors'
-import { verifyOne, verifyOneOrNone, verifyTruthy } from '../utility/utilityHelpers'
-import { EntityTimeStamp, TransactionStatus } from '../sdk/types'
-
-export interface StorageKnexOptions extends StorageProviderOptions {
-  /**
-   * Knex database interface initialized with valid connection configuration.
-   */
-  knex: Knex
-}
-
-export class StorageKnex extends StorageProvider implements WalletStorageProvider {
-  knex: Knex
-
-  constructor(options: StorageKnexOptions) {
-    super(options)
-    if (!options.knex) throw new WERR_INVALID_PARAMETER('options.knex', `valid`)
-    this.knex = options.knex
-  }
-
-  async readSettings(): Promise<TableSettings> {
-    return this.validateEntity(verifyOne(await this.toDb(undefined)<TableSettings>('settings')))
-  }
-
-  override async getProvenOrRawTx(txid: string, trx?: TrxToken): Promise<ProvenOrRawTx> {
-    const k = this.toDb(trx)
-    const r: ProvenOrRawTx = {
-      proven: undefined,
-      rawTx: undefined,
-      inputBEEF: undefined
-    }
-
-    r.proven = verifyOneOrNone(await this.findProvenTxs({ partial: { txid: txid } }))
-    if (!r.proven) {
-      const reqRawTx = verifyOneOrNone(
-        await k('proven_tx_reqs')
-          .where('txid', txid)
-          .whereIn('status', ['unsent', 'unmined', 'unconfirmed', 'sending', 'nosend', 'completed'])
-          .select('rawTx', 'inputBEEF')
-      )
-      if (reqRawTx) {
-        r.rawTx = Array.from(reqRawTx.rawTx)
-        r.inputBEEF = Array.from(reqRawTx.inputBEEF)
-      }
-    }
-    return r
-  }
-
-  dbTypeSubstring(source: string, fromOffset: number, forLength?: number) {
-    if (this.dbtype === 'MySQL') return `substring(${source} from ${fromOffset} for ${forLength!})`
-    return `substr(${source}, ${fromOffset}, ${forLength})`
-  }
-
-  override 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
-    if (Number.isInteger(offset) && Number.isInteger(length)) {
-      let rs: { rawTx: Buffer | null }[] = await this.toDb(trx).raw(
-        `select ${this.dbTypeSubstring('rawTx', offset! + 1, length)} as rawTx from proven_txs where txid = '${txid}'`
-      )
-      if (this.dbtype === 'MySQL') rs = (rs as unknown as { rawTx: Buffer | null }[][])[0]
-      const r = verifyOneOrNone(rs)
-      if (r && r.rawTx) {
-        rawTx = Array.from(r.rawTx)
-      } else {
-        let rs: { rawTx: Buffer | null }[] = await this.toDb(trx).raw(
-          `select ${this.dbTypeSubstring('rawTx', offset! + 1, length)} as rawTx from proven_tx_reqs where txid = '${txid}' and status in ('unsent', 'nosend', 'sending', 'unmined', 'completed', 'unfail')`
-        )
-        if (this.dbtype === 'MySQL') rs = (rs as unknown as { rawTx: Buffer | null }[][])[0]
-        const r = verifyOneOrNone(rs)
-        if (r && r.rawTx) {
-          rawTx = Array.from(r.rawTx)
-        }
-      }
-    } else {
-      const r = await this.getProvenOrRawTx(txid, trx)
-      if (r.proven) rawTx = r.proven.rawTx
-      else rawTx = r.rawTx
-    }
-    return rawTx
-  }
-
-  getProvenTxsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
-    const k = this.toDb(args.trx)
-    let q = k('proven_txs').where(function () {
-      this.whereExists(
-        k
-          .select('*')
-          .from('transactions')
-          .whereRaw(`proven_txs.provenTxId = transactions.provenTxId and transactions.userId = ${args.userId}`)
-      )
-    })
-    if (args.paged) {
-      q = q.limit(args.paged.limit)
-      q = q.offset(args.paged.offset || 0)
-    }
-    if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
-    return q
-  }
-  override async getProvenTxsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTx[]> {
-    const q = this.getProvenTxsForUserQuery(args)
-    const rs = await q
-    return this.validateEntities(rs)
-  }
-
-  getProvenTxReqsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
-    const k = this.toDb(args.trx)
-    let q = k('proven_tx_reqs').where(function () {
-      this.whereExists(
-        k
-          .select('*')
-          .from('transactions')
-          .whereRaw(`proven_tx_reqs.txid = transactions.txid and transactions.userId = ${args.userId}`)
-      )
-    })
-    if (args.paged) {
-      q = q.limit(args.paged.limit)
-      q = q.offset(args.paged.offset || 0)
-    }
-    if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
-    return q
-  }
-  override async getProvenTxReqsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTxReq[]> {
-    const q = this.getProvenTxReqsForUserQuery(args)
-    const rs = await q
-    return this.validateEntities(rs, undefined, ['notified'])
-  }
-
-  getTxLabelMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
-    const k = this.toDb(args.trx)
-    let q = k('tx_labels_map').whereExists(
-      k
-        .select('*')
-        .from('tx_labels')
-        .whereRaw(`tx_labels.txLabelId = tx_labels_map.txLabelId and tx_labels.userId = ${args.userId}`)
-    )
-    if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
-    if (args.paged) {
-      q = q.limit(args.paged.limit)
-      q = q.offset(args.paged.offset || 0)
-    }
-    return q
-  }
-  override async getTxLabelMapsForUser(args: FindForUserSincePagedArgs): Promise<TableTxLabelMap[]> {
-    const q = this.getTxLabelMapsForUserQuery(args)
-    const rs = await q
-    return this.validateEntities(rs, undefined, ['isDeleted'])
-  }
-
-  getOutputTagMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
-    const k = this.toDb(args.trx)
-    let q = k('output_tags_map').whereExists(
-      k
-        .select('*')
-        .from('output_tags')
-        .whereRaw(`output_tags.outputTagId = output_tags_map.outputTagId and output_tags.userId = ${args.userId}`)
-    )
-    if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
-    if (args.paged) {
-      q = q.limit(args.paged.limit)
-      q = q.offset(args.paged.offset || 0)
-    }
-    return q
-  }
-  override async getOutputTagMapsForUser(args: FindForUserSincePagedArgs): Promise<TableOutputTagMap[]> {
-    const q = this.getOutputTagMapsForUserQuery(args)
-    const rs = await q
-    return this.validateEntities(rs, undefined, ['isDeleted'])
-  }
-
-  override async listActions(auth: AuthId, vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
-    if (!auth.userId) throw new WERR_UNAUTHORIZED()
-    return await listActions(this, auth, vargs)
-  }
-  override async listOutputs(auth: AuthId, vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
-    if (!auth.userId) throw new WERR_UNAUTHORIZED()
-    return await listOutputs(this, auth, vargs)
-  }
-
-  override async insertProvenTx(tx: TableProvenTx, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.provenTxId === 0) delete e.provenTxId
-    const [id] = await this.toDb(trx)<TableProvenTx>('proven_txs').insert(e)
-    tx.provenTxId = id
-    return tx.provenTxId
-  }
-
-  override async insertProvenTxReq(tx: TableProvenTxReq, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.provenTxReqId === 0) delete e.provenTxReqId
-    const [id] = await this.toDb(trx)<TableProvenTxReq>('proven_tx_reqs').insert(e)
-    tx.provenTxReqId = id
-    return tx.provenTxReqId
-  }
-
-  override async insertUser(user: TableUser, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(user, trx)
-    if (e.userId === 0) delete e.userId
-    const [id] = await this.toDb(trx)<TableUser>('users').insert(e)
-    user.userId = id
-    return user.userId
-  }
-
-  override 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)
-  }
-
-  override async insertCertificate(certificate: TableCertificateX, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(certificate, trx, undefined, ['isDeleted'])
-    if (e.certificateId === 0) delete e.certificateId
-
-    const logger = e.logger
-    if (e.logger) delete e.logger
-
-    const fields = e.fields
-    if (e.fields) delete e.fields
-
-    const [id] = await this.toDb(trx)<TableCertificate>('certificates').insert(e)
-    certificate.certificateId = id
-
-    if (fields) {
-      for (const field of fields) {
-        field.certificateId = id
-        field.userId = certificate.userId
-        await this.insertCertificateField(field, trx)
-      }
-    }
-
-    return certificate.certificateId
-  }
-
-  override async insertCertificateField(certificateField: TableCertificateField, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(certificateField, trx)
-    await this.toDb(trx)<TableCertificate>('certificate_fields').insert(e)
-  }
-
-  override 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 [id] = await this.toDb(trx)<TableOutputBasket>('output_baskets').insert(e)
-    basket.basketId = id
-    return basket.basketId
-  }
-
-  override async insertTransaction(tx: TableTransaction, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(tx, trx)
-    if (e.transactionId === 0) delete e.transactionId
-    const [id] = await this.toDb(trx)<TableTransaction>('transactions').insert(e)
-    tx.transactionId = id
-    return tx.transactionId
-  }
-
-  override async insertCommission(commission: TableCommission, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(commission, trx)
-    if (e.commissionId === 0) delete e.commissionId
-    const [id] = await this.toDb(trx)<TableCommission>('commissions').insert(e)
-    commission.commissionId = id
-    return commission.commissionId
-  }
-
-  override async insertOutput(output: TableOutput, trx?: TrxToken): Promise<number> {
-    try {
-      const e = await this.validateEntityForInsert(output, trx)
-      if (e.outputId === 0) delete e.outputId
-      const [id] = await this.toDb(trx)<TableOutput>('outputs').insert(e)
-      output.outputId = id
-      return output.outputId
-    } catch (e) {
-      throw e
-    }
-  }
-
-  override 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 [id] = await this.toDb(trx)<TableOutputTag>('output_tags').insert(e)
-    tag.outputTagId = id
-    return tag.outputTagId
-  }
-
-  override async insertOutputTagMap(tagMap: TableOutputTagMap, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(tagMap, trx, undefined, ['isDeleted'])
-    const [id] = await this.toDb(trx)<TableOutputTagMap>('output_tags_map').insert(e)
-  }
-
-  override 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 [id] = await this.toDb(trx)<TableTxLabel>('tx_labels').insert(e)
-    label.txLabelId = id
-    return label.txLabelId
-  }
-
-  override async insertTxLabelMap(labelMap: TableTxLabelMap, trx?: TrxToken): Promise<void> {
-    const e = await this.validateEntityForInsert(labelMap, trx, undefined, ['isDeleted'])
-    const [id] = await this.toDb(trx)<TableTxLabelMap>('tx_labels_map').insert(e)
-  }
-
-  override async insertMonitorEvent(event: TableMonitorEvent, trx?: TrxToken): Promise<number> {
-    const e = await this.validateEntityForInsert(event, trx)
-    if (e.id === 0) delete e.id
-    const [id] = await this.toDb(trx)<TableMonitorEvent>('monitor_events').insert(e)
-    event.id = id
-    return event.id
-  }
-
-  override 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 [id] = await this.toDb(trx)<TableSyncState>('sync_states').insert(e)
-    syncState.syncStateId = id
-    return syncState.syncStateId
-  }
-
-  override async updateCertificateField(
-    certificateId: number,
-    fieldName: string,
-    update: Partial<TableCertificateField>,
-    trx?: TrxToken
-  ): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableCertificateField>('certificate_fields')
-      .where({ certificateId, fieldName })
-      .update(this.validatePartialForUpdate(update))
-  }
-  override async updateCertificate(id: number, update: Partial<TableCertificate>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableCertificate>('certificates')
-      .where({ certificateId: id })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateCommission(id: number, update: Partial<TableCommission>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableCommission>('commissions')
-      .where({ commissionId: id })
-      .update(this.validatePartialForUpdate(update))
-  }
-  override async updateOutputBasket(id: number, update: Partial<TableOutputBasket>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableOutputBasket>('output_baskets')
-      .where({ basketId: id })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateOutput(id: number, update: Partial<TableOutput>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableOutput>('outputs')
-      .where({ outputId: id })
-      .update(this.validatePartialForUpdate(update))
-  }
-  override async updateOutputTagMap(
-    outputId: number,
-    tagId: number,
-    update: Partial<TableOutputTagMap>,
-    trx?: TrxToken
-  ): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableOutputTagMap>('output_tags_map')
-      .where({ outputId, outputTagId: tagId })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateOutputTag(id: number, update: Partial<TableOutputTag>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableOutputTag>('output_tags')
-      .where({ outputTagId: id })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateProvenTxReq(
-    id: number | number[],
-    update: Partial<TableProvenTxReq>,
-    trx?: TrxToken
-  ): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    let r: number
-    if (Array.isArray(id)) {
-      r = await this.toDb(trx)<TableProvenTxReq>('proven_tx_reqs')
-        .whereIn('provenTxReqId', id)
-        .update(this.validatePartialForUpdate(update))
-    } else if (Number.isInteger(id)) {
-      r = await this.toDb(trx)<TableProvenTxReq>('proven_tx_reqs')
-        .where({ provenTxReqId: id })
-        .update(this.validatePartialForUpdate(update))
-    } else {
-      throw new WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
-    }
-    return r
-  }
-  override async updateProvenTx(id: number, update: Partial<TableProvenTx>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableProvenTx>('proven_txs')
-      .where({ provenTxId: id })
-      .update(this.validatePartialForUpdate(update))
-  }
-  override async updateSyncState(id: number, update: Partial<TableSyncState>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableSyncState>('sync_states')
-      .where({ syncStateId: id })
-      .update(this.validatePartialForUpdate(update, ['when'], ['init']))
-  }
-  override async updateTransaction(
-    id: number | number[],
-    update: Partial<TableTransaction>,
-    trx?: TrxToken
-  ): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    let r: number
-    if (Array.isArray(id)) {
-      r = await this.toDb(trx)<TableTransaction>('transactions')
-        .whereIn('transactionId', id)
-        .update(await this.validatePartialForUpdate(update))
-    } else if (Number.isInteger(id)) {
-      r = await this.toDb(trx)<TableTransaction>('transactions')
-        .where({ transactionId: id })
-        .update(await this.validatePartialForUpdate(update))
-    } else {
-      throw new WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
-    }
-    return r
-  }
-  override async updateTxLabelMap(
-    transactionId: number,
-    txLabelId: number,
-    update: Partial<TableTxLabelMap>,
-    trx?: TrxToken
-  ): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableTxLabelMap>('tx_labels_map')
-      .where({ transactionId, txLabelId })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateTxLabel(id: number, update: Partial<TableTxLabel>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableTxLabel>('tx_labels')
-      .where({ txLabelId: id })
-      .update(this.validatePartialForUpdate(update, undefined, ['isDeleted']))
-  }
-  override async updateUser(id: number, update: Partial<TableUser>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableUser>('users').where({ userId: id }).update(this.validatePartialForUpdate(update))
-  }
-  override async updateMonitorEvent(id: number, update: Partial<TableMonitorEvent>, trx?: TrxToken): Promise<number> {
-    await this.verifyReadyForDatabaseAccess(trx)
-    return await this.toDb(trx)<TableMonitorEvent>('monitor_events')
-      .where({ id })
-      .update(this.validatePartialForUpdate(update))
-  }
-
-  setupQuery<T extends object>(table: string, args: FindPartialSincePagedArgs<T>): Knex.QueryBuilder {
-    let q = this.toDb(args.trx)<T>(table)
-    if (args.partial && Object.keys(args.partial).length > 0) q.where(args.partial)
-    if (args.since) q.where('updated_at', '>=', this.validateDateForWhere(args.since))
-    if (args.orderDescending) {
-      let sortColumn = ''
-      switch (table) {
-        case 'certificates':
-          sortColumn = 'certificateId'
-          break
-        case 'commissions':
-          sortColumn = 'commissionId'
-          break
-        case 'output_baskets':
-          sortColumn = 'basketId'
-          break
-        case 'outputs':
-          sortColumn = 'outputId'
-          break
-        case 'output_tags':
-          sortColumn = 'outputTagId'
-          break
-        case 'proven_tx_reqs':
-          sortColumn = 'provenTxReqId'
-          break
-        case 'proven_txs':
-          sortColumn = 'provenTxId'
-          break
-        case 'sync_states':
-          sortColumn = 'syncStateId'
-          break
-        case 'transactions':
-          sortColumn = 'transactionId'
-          break
-        case 'tx_labels':
-          sortColumn = 'txLabelId'
-          break
-        case 'users':
-          sortColumn = 'userId'
-          break
-        case 'monitor_events':
-          sortColumn = 'id'
-          break
-        default:
-          break
-      }
-      if (sortColumn !== '') {
-        q.orderBy(sortColumn, 'desc')
-      }
-    }
-    if (args.paged) {
-      q.limit(args.paged.limit)
-      q.offset(args.paged.offset || 0)
-    }
-    return q
-  }
-
-  findCertificateFieldsQuery(args: FindCertificateFieldsArgs): Knex.QueryBuilder {
-    return this.setupQuery('certificate_fields', args)
-  }
-  findCertificatesQuery(args: FindCertificatesArgs): Knex.QueryBuilder {
-    const q = this.setupQuery('certificates', args)
-    if (args.certifiers && args.certifiers.length > 0) q.whereIn('certifier', args.certifiers)
-    if (args.types && args.types.length > 0) q.whereIn('type', args.types)
-    return q
-  }
-  findCommissionsQuery(args: FindCommissionsArgs): Knex.QueryBuilder {
-    if (args.partial.lockingScript)
-      throw new WERR_INVALID_PARAMETER(
-        'partial.lockingScript',
-        `undefined. Commissions may not be found by lockingScript value.`
-      )
-    return this.setupQuery('commissions', args)
-  }
-  findOutputBasketsQuery(args: FindOutputBasketsArgs): Knex.QueryBuilder {
-    return this.setupQuery('output_baskets', args)
-  }
-  findOutputsQuery(args: FindOutputsArgs, count?: boolean): Knex.QueryBuilder {
-    if (args.partial.lockingScript)
-      throw new WERR_INVALID_PARAMETER(
-        'args.partial.lockingScript',
-        `undefined. Outputs may not be found by lockingScript value.`
-      )
-    const q = this.setupQuery('outputs', args)
-    if (args.txStatus && args.txStatus.length > 0) {
-      q.whereRaw(
-        `(select status from transactions where transactions.transactionId = outputs.transactionId) in (${args.txStatus.map(s => `'${s}'`).join(',')})`
-      )
-    }
-    if (args.noScript && !count) {
-      const columns = outputColumnsWithoutLockingScript.map(c => `outputs.${c}`)
-      q.select(columns)
-    }
-    return q
-  }
-  findOutputTagMapsQuery(args: FindOutputTagMapsArgs): Knex.QueryBuilder {
-    const q = this.setupQuery('output_tags_map', args)
-    if (args.tagIds && args.tagIds.length > 0) q.whereIn('outputTagId', args.tagIds)
-    return q
-  }
-  findOutputTagsQuery(args: FindOutputTagsArgs): Knex.QueryBuilder {
-    return this.setupQuery('output_tags', args)
-  }
-  findProvenTxReqsQuery(args: FindProvenTxReqsArgs): Knex.QueryBuilder {
-    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 q = this.setupQuery('proven_tx_reqs', args)
-    if (args.status && args.status.length > 0) q.whereIn('status', args.status)
-    if (args.txids) {
-      const txids = args.txids.filter(txid => txid !== undefined)
-      if (txids.length > 0) q.whereIn('txid', txids)
-    }
-    return q
-  }
-  findProvenTxsQuery(args: FindProvenTxsArgs): Knex.QueryBuilder {
-    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.`
-      )
-    return this.setupQuery('proven_txs', args)
-  }
-  findSyncStatesQuery(args: FindSyncStatesArgs): Knex.QueryBuilder {
-    return this.setupQuery('sync_states', args)
-  }
-  findTransactionsQuery(args: FindTransactionsArgs, count?: boolean): Knex.QueryBuilder {
-    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 q = this.setupQuery('transactions', args)
-    if (args.status && args.status.length > 0) q.whereIn('status', args.status)
-    if (args.noRawTx && !count) {
-      const columns = transactionColumnsWithoutRawTx.map(c => `transactions.${c}`)
-      q.select(columns)
-    }
-    return q
-  }
-  findTxLabelMapsQuery(args: FindTxLabelMapsArgs): Knex.QueryBuilder {
-    const q = this.setupQuery('tx_labels_map', args)
-    if (args.labelIds && args.labelIds.length > 0) q.whereIn('txLabelId', args.labelIds)
-    return q
-  }
-  findTxLabelsQuery(args: FindTxLabelsArgs): Knex.QueryBuilder {
-    return this.setupQuery('tx_labels', args)
-  }
-  findUsersQuery(args: FindUsersArgs): Knex.QueryBuilder {
-    return this.setupQuery('users', args)
-  }
-  findMonitorEventsQuery(args: FindMonitorEventsArgs): Knex.QueryBuilder {
-    return this.setupQuery('monitor_events', args)
-  }
-
-  override 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)
-  }
-  override 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)
-  }
-  override 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)
-  }
-
-  override async findCertificateFields(args: FindCertificateFieldsArgs): Promise<TableCertificateField[]> {
-    return this.validateEntities(await this.findCertificateFieldsQuery(args))
-  }
-  override async findCertificates(args: FindCertificatesArgs): Promise<TableCertificateX[]> {
-    const q = this.findCertificatesQuery(args)
-    let r: TableCertificateX[] = await q
-    r = this.validateEntities(r, undefined, ['isDeleted'])
-    if (args.includeFields) {
-      for (const c of r) {
-        c.fields = this.validateEntities(
-          await this.findCertificateFields({
-            partial: { certificateId: c.certificateId, userId: c.userId },
-            trx: args.trx
-          })
-        )
-      }
-    }
-    return r
-  }
-  override async findCommissions(args: FindCommissionsArgs): Promise<TableCommission[]> {
-    const q = this.findCommissionsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isRedeemed'])
-  }
-  override async findOutputBaskets(args: FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
-    const q = this.findOutputBasketsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isDeleted'])
-  }
-  override async findOutputs(args: FindOutputsArgs): Promise<TableOutput[]> {
-    const q = this.findOutputsQuery(args)
-    const r = await q
-    if (!args.noScript) {
-      for (const o of r) {
-        await this.validateOutputScript(o, args.trx)
-      }
-    }
-    return this.validateEntities(r, undefined, ['spendable', 'change'])
-  }
-  override async findOutputTagMaps(args: FindOutputTagMapsArgs): Promise<TableOutputTagMap[]> {
-    const q = this.findOutputTagMapsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isDeleted'])
-  }
-  override async findOutputTags(args: FindOutputTagsArgs): Promise<TableOutputTag[]> {
-    const q = this.findOutputTagsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isDeleted'])
-  }
-  override async findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]> {
-    const q = this.findProvenTxReqsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['notified'])
-  }
-  override async findProvenTxs(args: FindProvenTxsArgs): Promise<TableProvenTx[]> {
-    const q = this.findProvenTxsQuery(args)
-    const r = await q
-    return this.validateEntities(r)
-  }
-  override async findSyncStates(args: FindSyncStatesArgs): Promise<TableSyncState[]> {
-    const q = this.findSyncStatesQuery(args)
-    const r = await q
-    return this.validateEntities(r, ['when'], ['init'])
-  }
-  override async findTransactions(args: FindTransactionsArgs): Promise<TableTransaction[]> {
-    const q = this.findTransactionsQuery(args)
-    const r = await q
-    if (!args.noRawTx) {
-      for (const t of r) {
-        await this.validateRawTransaction(t, args.trx)
-      }
-    }
-    return this.validateEntities(r, undefined, ['isOutgoing'])
-  }
-  override async findTxLabelMaps(args: FindTxLabelMapsArgs): Promise<TableTxLabelMap[]> {
-    const q = this.findTxLabelMapsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isDeleted'])
-  }
-  override async findTxLabels(args: FindTxLabelsArgs): Promise<TableTxLabel[]> {
-    const q = this.findTxLabelsQuery(args)
-    const r = await q
-    return this.validateEntities(r, undefined, ['isDeleted'])
-  }
-  override async findUsers(args: FindUsersArgs): Promise<TableUser[]> {
-    const q = this.findUsersQuery(args)
-    const r = await q
-    return this.validateEntities(r)
-  }
-  override async findMonitorEvents(args: FindMonitorEventsArgs): Promise<TableMonitorEvent[]> {
-    const q = this.findMonitorEventsQuery(args)
-    const r = await q
-    return this.validateEntities(r, ['when'], undefined)
-  }
-
-  async getCount<T extends object>(q: Knex.QueryBuilder<T, T[]>): Promise<number> {
-    q.count()
-    const r = await q
-    return r[0]['count(*)']
-  }
-
-  override async countCertificateFields(args: FindCertificateFieldsArgs): Promise<number> {
-    return await this.getCount(this.findCertificateFieldsQuery(args))
-  }
-  override async countCertificates(args: FindCertificatesArgs): Promise<number> {
-    return await this.getCount(this.findCertificatesQuery(args))
-  }
-  override async countCommissions(args: FindCommissionsArgs): Promise<number> {
-    return await this.getCount(this.findCommissionsQuery(args))
-  }
-  override async countOutputBaskets(args: FindOutputBasketsArgs): Promise<number> {
-    return await this.getCount(this.findOutputBasketsQuery(args))
-  }
-  override async countOutputs(args: FindOutputsArgs): Promise<number> {
-    return await this.getCount(this.findOutputsQuery(args, true))
-  }
-  override async countOutputTagMaps(args: FindOutputTagMapsArgs): Promise<number> {
-    return await this.getCount(this.findOutputTagMapsQuery(args))
-  }
-  override async countOutputTags(args: FindOutputTagsArgs): Promise<number> {
-    return await this.getCount(this.findOutputTagsQuery(args))
-  }
-  override async countProvenTxReqs(args: FindProvenTxReqsArgs): Promise<number> {
-    return await this.getCount(this.findProvenTxReqsQuery(args))
-  }
-  override async countProvenTxs(args: FindProvenTxsArgs): Promise<number> {
-    return await this.getCount(this.findProvenTxsQuery(args))
-  }
-  override async countSyncStates(args: FindSyncStatesArgs): Promise<number> {
-    return await this.getCount(this.findSyncStatesQuery(args))
-  }
-  override async countTransactions(args: FindTransactionsArgs): Promise<number> {
-    return await this.getCount(this.findTransactionsQuery(args, true))
-  }
-  override async countTxLabelMaps(args: FindTxLabelMapsArgs): Promise<number> {
-    return await this.getCount(this.findTxLabelMapsQuery(args))
-  }
-  override async countTxLabels(args: FindTxLabelsArgs): Promise<number> {
-    return await this.getCount(this.findTxLabelsQuery(args))
-  }
-  override async countUsers(args: FindUsersArgs): Promise<number> {
-    return await this.getCount(this.findUsersQuery(args))
-  }
-  override async countMonitorEvents(args: FindMonitorEventsArgs): Promise<number> {
-    return await this.getCount(this.findMonitorEventsQuery(args))
-  }
-
-  override async destroy(): Promise<void> {
-    await this.knex?.destroy()
-  }
-
-  override async migrate(storageName: string, storageIdentityKey: string): Promise<string> {
-    const config = {
-      migrationSource: new KnexMigrations(this.chain, storageName, storageIdentityKey, 1024)
-    }
-    await this.knex.migrate.latest(config)
-    const version = await this.knex.migrate.currentVersion(config)
-    return version
-  }
-
-  override async dropAllData(): Promise<void> {
-    // Only using migrations to migrate down, don't need valid properties for settings table.
-    const config = {
-      migrationSource: new KnexMigrations('test', '', '', 1024)
-    }
-    const count = Object.keys(config.migrationSource.migrations).length
-    for (let i = 0; i < count; i++) {
-      try {
-        const r = await this.knex.migrate.down(config)
-        if (!r) {
-          console.error(`Migration returned falsy result await this.knex.migrate.down(config)`)
-          break
-        }
-      } catch (eu: unknown) {
-        break
-      }
-    }
-  }
-
-  override async transaction<T>(scope: (trx: TrxToken) => Promise<T>, trx?: TrxToken): Promise<T> {
-    if (trx) return await scope(trx)
-
-    return await this.knex.transaction<T>(async knextrx => {
-      const trx = knextrx as TrxToken
-      return await scope(trx)
-    })
-  }
-
-  /**
-   * Convert the standard optional `TrxToken` parameter into either a direct knex database instance,
-   * or a Knex.Transaction as appropriate.
-   */
-  toDb(trx?: TrxToken) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const db = !trx ? this.knex : <Knex.Transaction<any, any[]>>trx
-    this.whenLastAccess = new Date()
-    return db
-  }
-
-  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
-  }
-
-  _verifiedReadyForDatabaseAccess: boolean = false
-
-  /**
-   * Make sure database is ready for access:
-   *
-   * - dateScheme is known
-   * - foreign key constraints are enabled
-   *
-   * @param trx
-   */
-  async verifyReadyForDatabaseAccess(trx?: TrxToken): Promise<DBType> {
-    if (!this._settings) {
-      this._settings = await this.readSettings()
-    }
-
-    if (!this._verifiedReadyForDatabaseAccess) {
-      // Make sure foreign key constraint checking is turned on in SQLite.
-      if (this._settings.dbtype === 'SQLite') {
-        await this.toDb(trx).raw('PRAGMA foreign_keys = ON;')
-      }
-
-      this._verifiedReadyForDatabaseAccess = true
-    }
-
-    return this._settings.dbtype
-  }
-
-  /**
-   * 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 || typeof val[0] === 'number')) {
-        v[key] = Buffer.from(val)
-      } else if (val === undefined) {
-        v[key] = null
-      }
-    }
-    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 || typeof val[0] === 'number')) {
-        v[key] = Buffer.from(val)
-      } else if (val === undefined) {
-        v[key] = null
-      }
-    }
-    this.isDirty = true
-    return v
-  }
-
-  override async getLabelsForTransactionId(transactionId?: number, trx?: TrxToken): Promise<TableTxLabel[]> {
-    if (transactionId === undefined) return []
-    const labels = await this.toDb(trx)<TableTxLabel>('tx_labels')
-      .join('tx_labels_map', 'tx_labels_map.txLabelId', 'tx_labels.txLabelId')
-      .where('tx_labels_map.transactionId', transactionId)
-      .whereNot('tx_labels_map.isDeleted', true)
-      .whereNot('tx_labels.isDeleted', true)
-    return this.validateEntities(labels, undefined, ['isDeleted'])
-  }
-
-  override async getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]> {
-    const tags = await this.toDb(trx)<TableOutputTag>('output_tags')
-      .join('output_tags_map', 'output_tags_map.outputTagId', 'output_tags.outputTagId')
-      .where('output_tags_map.outputId', outputId)
-      .whereNot('output_tags_map.isDeleted', true)
-      .whereNot('output_tags.isDeleted', true)
-    return this.validateEntities(tags, undefined, ['isDeleted'])
-  }
-
-  override async purgeData(params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
-    return await purgeData(this, params, trx)
-  }
-
-  override async reviewStatus(args: { agedLimit: Date; trx?: TrxToken }): Promise<{ log: string }> {
-    return await reviewStatus(this, args)
-  }
-
-  /**
-   * Counts the outputs for userId in basketId that are spendable: true
-   * AND whose transaction status is one of:
-   * - completed
-   * - unproven
-   * - sending (if excludeSending is false)
-   */
-  async countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {
-    const status: TransactionStatus[] = ['completed', 'unproven']
-    if (!excludeSending) status.push('sending')
-    const statusText = status.map(s => `'${s}'`).join(',')
-    const txStatusCondition = `(SELECT status FROM transactions WHERE outputs.transactionId = transactions.transactionId) in (${statusText})`
-    let q = this.knex<TableOutput>('outputs').where({ userId, spendable: true, basketId }).whereRaw(txStatusCondition)
-    const count = await this.getCount(q)
-    return count
-  }
-
-  /**
-   *  Finds closest matching available change output to use as input for new transaction.
-   *
-   * Transactionally allocate the output such that
-   */
-  async allocateChangeInput(
-    userId: number,
-    basketId: number,
-    targetSatoshis: number,
-    exactSatoshis: number | undefined,
-    excludeSending: boolean,
-    transactionId: number
-  ): Promise<TableOutput | undefined> {
-    const status: TransactionStatus[] = ['completed', 'unproven']
-    if (!excludeSending) status.push('sending')
-    const statusText = status.map(s => `'${s}'`).join(',')
-
-    const r: TableOutput | undefined = await this.knex.transaction(async trx => {
-      const txStatusCondition = `AND (SELECT status FROM transactions WHERE outputs.transactionId = transactions.transactionId) in (${statusText})`
-
-      let outputId: number | undefined
-      const setOutputId = async (rawQuery: string): Promise<void> => {
-        let oidr = await trx.raw(rawQuery)
-        outputId = undefined
-        if (!oidr['outputId'] && oidr.length > 0) oidr = oidr[0]
-        if (!oidr['outputId'] && oidr.length > 0) oidr = oidr[0]
-        if (oidr['outputId']) outputId = Number(oidr['outputId'])
-      }
-
-      if (exactSatoshis !== undefined) {
-        // Find outputId of output that with exactSatoshis
-        await setOutputId(`
-                SELECT outputId 
-                FROM outputs
-                WHERE userId = ${userId} 
-                    AND spendable = 1 
-                    AND basketId = ${basketId}
-                    ${txStatusCondition}
-                    AND satoshis = ${exactSatoshis}
-                LIMIT 1;
-                `)
-      }
-
-      if (outputId === undefined) {
-        // Find outputId of output that would at least fund targetSatoshis
-        await setOutputId(`
-                    SELECT outputId 
-                    FROM outputs
-                    WHERE userId = ${userId} 
-                        AND spendable = 1 
-                        AND basketId = ${basketId}
-                        ${txStatusCondition}
-                        AND satoshis - ${targetSatoshis} = (
-                            SELECT MIN(satoshis - ${targetSatoshis}) 
-                            FROM outputs 
-                            WHERE userId = ${userId} 
-                            AND spendable = 1 
-                            AND basketId = ${basketId}
-                            ${txStatusCondition}
-                            AND satoshis - ${targetSatoshis} >= 0
-                        )
-                    LIMIT 1;
-                    `)
-      }
-
-      if (outputId === undefined) {
-        // Find outputId of output that would add the most fund targetSatoshis
-        await setOutputId(`
-                    SELECT outputId 
-                    FROM outputs
-                    WHERE userId = ${userId} 
-                        AND spendable = 1 
-                        AND basketId = ${basketId}
-                        ${txStatusCondition}
-                        AND satoshis - ${targetSatoshis} = (
-                            SELECT MAX(satoshis - ${targetSatoshis}) 
-                            FROM outputs 
-                            WHERE userId = ${userId} 
-                            AND spendable = 1 
-                            AND basketId = ${basketId}
-                            ${txStatusCondition}
-                            AND satoshis - ${targetSatoshis} < 0
-                        )
-                    LIMIT 1;
-                    `)
-      }
-
-      if (outputId === undefined) return undefined
-
-      await this.updateOutput(
-        outputId,
-        {
-          spendable: false,
-          spentBy: transactionId
-        },
-        trx
-      )
-
-      const r = verifyTruthy(await this.findOutputById(outputId, trx))
-      return r
-    })
-
-    return r
-  }
-
-  /**
-   * Helper to force uniform behavior across database engines.
-   * Use to process all individual records with time stamps 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 (Buffer.isBuffer(val)) {
-        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
-  }
-
-  async adminStats(adminIdentityKey: string): Promise<AdminStatsResult> {
-    if (this.dbtype !== 'MySQL') throw new WERR_NOT_IMPLEMENTED('adminStats, only MySQL is supported')
-
-    const monitorEvent = verifyOneOrNone(
-      await this.findMonitorEvents({
-        partial: { event: 'MonitorCallHistory' },
-        orderDescending: true,
-        paged: { limit: 1 }
-      })
-    )
-    const monitorStats: ServicesCallHistory | undefined = monitorEvent ? JSON.parse(monitorEvent.details!) : undefined
-    const servicesStats = this.getServices().getServicesCallHistory(true)
-    await this.insertMonitorEvent({
-      event: 'ServicesCallHistory',
-      details: JSON.stringify(servicesStats),
-      created_at: new Date(),
-      updated_at: new Date(),
-      id: 0
-    })
-
-    const one_day_ago = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
-    const one_week_ago = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString()
-    const one_month_ago = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString()
-
-    const [
-      [
-        {
-          usersDay,
-          usersMonth,
-          usersWeek,
-          usersTotal,
-          transactionsDay,
-          transactionsMonth,
-          transactionsWeek,
-          transactionsTotal,
-          txCompletedDay,
-          txCompletedMonth,
-          txCompletedWeek,
-          txCompletedTotal,
-          txFailedDay,
-          txFailedMonth,
-          txFailedWeek,
-          txFailedTotal,
-          txUnprocessedDay,
-          txUnprocessedMonth,
-          txUnprocessedWeek,
-          txUnprocessedTotal,
-          txSendingDay,
-          txSendingMonth,
-          txSendingWeek,
-          txSendingTotal,
-          txUnprovenDay,
-          txUnprovenMonth,
-          txUnprovenWeek,
-          txUnprovenTotal,
-          txUnsignedDay,
-          txUnsignedMonth,
-          txUnsignedWeek,
-          txUnsignedTotal,
-          txNosendDay,
-          txNosendMonth,
-          txNosendWeek,
-          txNosendTotal,
-          txNonfinalDay,
-          txNonfinalMonth,
-          txNonfinalWeek,
-          txNonfinalTotal,
-          txUnfailDay,
-          txUnfailMonth,
-          txUnfailWeek,
-          txUnfailTotal,
-          satoshisDefaultDay,
-          satoshisDefaultMonth,
-          satoshisDefaultWeek,
-          satoshisDefaultTotal,
-          satoshisOtherDay,
-          satoshisOtherMonth,
-          satoshisOtherWeek,
-          satoshisOtherTotal,
-          basketsDay,
-          basketsMonth,
-          basketsWeek,
-          basketsTotal,
-          labelsDay,
-          labelsMonth,
-          labelsWeek,
-          labelsTotal,
-          tagsDay,
-          tagsMonth,
-          tagsWeek,
-          tagsTotal
-        }
-      ]
-    ] = await this.knex.raw(`
-select
-    (select count(*) from users where created_at > '${one_day_ago}') as usersDay,
-    (select count(*) from users where created_at > '${one_week_ago}') as usersWeek,
-    (select count(*) from users where created_at > '${one_month_ago}') as usersMonth,
-	  (select count(*) from users) as usersTotal,
-    (select count(*) from transactions where created_at > '${one_day_ago}') as transactionsDay,
-    (select count(*) from transactions where created_at > '${one_week_ago}') as transactionsWeek,
-    (select count(*) from transactions where created_at > '${one_month_ago}') as transactionsMonth,
-	  (select count(*) from transactions) as transactionsTotal,
-    (select count(*) from transactions where status = 'completed' and created_at > '${one_day_ago}') as txCompletedDay,
-    (select count(*) from transactions where status = 'completed' and created_at > '${one_week_ago}') as txCompletedWeek,
-    (select count(*) from transactions where status = 'completed' and created_at > '${one_month_ago}') as txCompletedMonth,
-	  (select count(*) from transactions where status = 'completed') as txCompletedTotal,
-    (select count(*) from transactions where status = 'failed' and created_at > '${one_day_ago}') as txFailedDay,
-    (select count(*) from transactions where status = 'failed' and created_at > '${one_week_ago}') as txFailedWeek,
-    (select count(*) from transactions where status = 'failed' and created_at > '${one_month_ago}') as txFailedMonth,
-	  (select count(*) from transactions where status = 'failed') as txFailedTotal,
-    (select count(*) from transactions where status = 'unprocessed' and created_at > '${one_day_ago}') as txUnprocessedDay,
-    (select count(*) from transactions where status = 'unprocessed' and created_at > '${one_week_ago}') as txUnprocessedWeek,
-    (select count(*) from transactions where status = 'unprocessed' and created_at > '${one_month_ago}') as txUnprocessedMonth,
-	  (select count(*) from transactions where status = 'unprocessed') as txUnprocessedTotal,
-    (select count(*) from transactions where status = 'sending' and created_at > '${one_day_ago}') as txSendingDay,
-    (select count(*) from transactions where status = 'sending' and created_at > '${one_week_ago}') as txSendingWeek,
-    (select count(*) from transactions where status = 'sending' and created_at > '${one_month_ago}') as txSendingMonth,
-	  (select count(*) from transactions where status = 'sending') as txSendingTotal,
-    (select count(*) from transactions where status = 'unproven' and created_at > '${one_day_ago}') as txUnprovenDay,
-    (select count(*) from transactions where status = 'unproven' and created_at > '${one_week_ago}') as txUnprovenWeek,
-    (select count(*) from transactions where status = 'unproven' and created_at > '${one_month_ago}') as txUnprovenMonth,
-	  (select count(*) from transactions where status = 'unproven') as txUnprovenTotal,
-    (select count(*) from transactions where status = 'unsigned' and created_at > '${one_day_ago}') as txUnsignedDay,
-    (select count(*) from transactions where status = 'unsigned' and created_at > '${one_week_ago}') as txUnsignedWeek,
-    (select count(*) from transactions where status = 'unsigned' and created_at > '${one_month_ago}') as txUnsignedMonth,
-	  (select count(*) from transactions where status = 'unsigned') as txUnsignedTotal,
-    (select count(*) from transactions where status = 'nosend' and created_at > '${one_day_ago}') as txNosendDay,
-    (select count(*) from transactions where status = 'nosend' and created_at > '${one_week_ago}') as txNosendWeek,
-    (select count(*) from transactions where status = 'nosend' and created_at > '${one_month_ago}') as txNosendMonth,
-	  (select count(*) from transactions where status = 'nosend') as txNosendTotal,
-    (select count(*) from transactions where status = 'nonfinal' and created_at > '${one_day_ago}') as txNonfinalDay,
-    (select count(*) from transactions where status = 'nonfinal' and created_at > '${one_week_ago}') as txNonfinalWeek,
-    (select count(*) from transactions where status = 'nonfinal' and created_at > '${one_month_ago}') as txNonfinalMonth,
-	  (select count(*) from transactions where status = 'nonfinal') as txNonfinalTotal,
-    (select count(*) from transactions where status = 'unfail' and created_at > '${one_day_ago}') as txUnfailDay,
-    (select count(*) from transactions where status = 'unfail' and created_at > '${one_week_ago}') as txUnfailWeek,
-    (select count(*) from transactions where status = 'unfail' and created_at > '${one_month_ago}') as txUnfailMonth,
-	  (select count(*) from transactions where status = 'unfail') as txUnfailTotal,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 1 and created_at > '${one_day_ago}') as satoshisDefaultDay,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 1 and created_at > '${one_week_ago}') as satoshisDefaultWeek,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 1 and created_at > '${one_month_ago}') as satoshisDefaultMonth,
-	  (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 1) as satoshisDefaultTotal,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 0 and not basketId is null and created_at > '${one_day_ago}') as satoshisOtherDay,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 0 and not basketId is null and created_at > '${one_week_ago}') as satoshisOtherWeek,
-    (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 0 and not basketId is null and created_at > '${one_month_ago}') as satoshisOtherMonth,
-	  (select sum(satoshis) from outputs where spendable = 1 and \`change\` = 0 and not basketId is null) as satoshisOtherTotal,
-    (select count(*) from output_baskets where created_at > '${one_day_ago}') as basketsDay,
-    (select count(*) from output_baskets where created_at > '${one_week_ago}') as basketsWeek,
-    (select count(*) from output_baskets where created_at > '${one_month_ago}') as basketsMonth,
-	  (select count(*) from output_baskets) as basketsTotal,
-    (select count(*) from tx_labels where created_at > '${one_day_ago}') as labelsDay,
-    (select count(*) from tx_labels where created_at > '${one_week_ago}') as labelsWeek,
-    (select count(*) from tx_labels where created_at > '${one_month_ago}') as labelsMonth,
-	  (select count(*) from tx_labels) as labelsTotal,
-    (select count(*) from output_tags where created_at > '${one_day_ago}') as tagsDay,
-    (select count(*) from output_tags where created_at > '${one_week_ago}') as tagsWeek,
-    (select count(*) from output_tags where created_at > '${one_month_ago}') as tagsMonth,
-	  (select count(*) from output_tags) as tagsTotal
-      `)
-    const r: AdminStatsResult = {
-      monitorStats,
-      servicesStats,
-      requestedBy: adminIdentityKey,
-      when: new Date().toISOString(),
-      usersDay,
-      usersWeek,
-      usersMonth,
-      usersTotal,
-      transactionsDay,
-      transactionsWeek,
-      transactionsMonth,
-      transactionsTotal,
-      txCompletedDay,
-      txCompletedWeek,
-      txCompletedMonth,
-      txCompletedTotal,
-      txFailedDay,
-      txFailedWeek,
-      txFailedMonth,
-      txFailedTotal,
-      txUnprocessedDay,
-      txUnprocessedWeek,
-      txUnprocessedMonth,
-      txUnprocessedTotal,
-      txSendingDay,
-      txSendingWeek,
-      txSendingMonth,
-      txSendingTotal,
-      txUnprovenDay,
-      txUnprovenWeek,
-      txUnprovenMonth,
-      txUnprovenTotal,
-      txUnsignedDay,
-      txUnsignedWeek,
-      txUnsignedMonth,
-      txUnsignedTotal,
-      txNosendDay,
-      txNosendWeek,
-      txNosendMonth,
-      txNosendTotal,
-      txNonfinalDay,
-      txNonfinalWeek,
-      txNonfinalMonth,
-      txNonfinalTotal,
-      txUnfailDay,
-      txUnfailWeek,
-      txUnfailMonth,
-      txUnfailTotal,
-      satoshisDefaultDay: Number(satoshisDefaultDay),
-      satoshisDefaultWeek: Number(satoshisDefaultWeek),
-      satoshisDefaultMonth: Number(satoshisDefaultMonth),
-      satoshisDefaultTotal: Number(satoshisDefaultTotal),
-      satoshisOtherDay: Number(satoshisOtherDay),
-      satoshisOtherWeek: Number(satoshisOtherWeek),
-      satoshisOtherMonth: Number(satoshisOtherMonth),
-      satoshisOtherTotal: Number(satoshisOtherTotal),
-      basketsDay,
-      basketsWeek,
-      basketsMonth,
-      basketsTotal,
-      labelsDay,
-      labelsWeek,
-      labelsMonth,
-      labelsTotal,
-      tagsDay,
-      tagsWeek,
-      tagsMonth,
-      tagsTotal
-    }
-    return r
-  }
-}