@bsv/wallet-toolbox 1.5.21 → 1.6.2

package/src/storage/StorageKnex.ts

@@ -1,5 +1,4 @@
 import { ListActionsResult, ListOutputsResult } from '@bsv/sdk'
-import { sdk, verifyOne, verifyOneOrNone, verifyTruthy } from '../index.all'
 import {
   outputColumnsWithoutLockingScript,
   TableCertificate,
@@ -30,6 +29,35 @@ 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 { ValidListActionsArgs, ValidListOutputsArgs } from '../sdk/validationHelpers'
+import { EntityTimeStamp, TransactionStatus } from '../sdk/types'
 
 export interface StorageKnexOptions extends StorageProviderOptions {
   /**
@@ -38,12 +66,12 @@ export interface StorageKnexOptions extends StorageProviderOptions {
   knex: Knex
 }
 
-export class StorageKnex extends StorageProvider implements sdk.WalletStorageProvider {
+export class StorageKnex extends StorageProvider implements WalletStorageProvider {
   knex: Knex
 
   constructor(options: StorageKnexOptions) {
     super(options)
-    if (!options.knex) throw new sdk.WERR_INVALID_PARAMETER('options.knex', `valid`)
+    if (!options.knex) throw new WERR_INVALID_PARAMETER('options.knex', `valid`)
     this.knex = options.knex
   }
 
@@ -51,9 +79,9 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return this.validateEntity(verifyOne(await this.toDb(undefined)<TableSettings>('settings')))
   }
 
-  override async getProvenOrRawTx(txid: string, trx?: sdk.TrxToken): Promise<sdk.ProvenOrRawTx> {
+  override async getProvenOrRawTx(txid: string, trx?: TrxToken): Promise<ProvenOrRawTx> {
     const k = this.toDb(trx)
-    const r: sdk.ProvenOrRawTx = {
+    const r: ProvenOrRawTx = {
       proven: undefined,
       rawTx: undefined,
       inputBEEF: undefined
@@ -84,7 +112,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     txid?: string,
     offset?: number,
     length?: number,
-    trx?: sdk.TrxToken
+    trx?: TrxToken
   ): Promise<number[] | undefined> {
     if (!txid) return undefined
     if (!this.isAvailable()) await this.makeAvailable()
@@ -116,7 +144,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return rawTx
   }
 
-  getProvenTxsForUserQuery(args: sdk.FindForUserSincePagedArgs): Knex.QueryBuilder {
+  getProvenTxsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
     const k = this.toDb(args.trx)
     let q = k('proven_txs').where(function () {
       this.whereExists(
@@ -133,13 +161,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
     return q
   }
-  override async getProvenTxsForUser(args: sdk.FindForUserSincePagedArgs): Promise<TableProvenTx[]> {
+  override async getProvenTxsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTx[]> {
     const q = this.getProvenTxsForUserQuery(args)
     const rs = await q
     return this.validateEntities(rs)
   }
 
-  getProvenTxReqsForUserQuery(args: sdk.FindForUserSincePagedArgs): Knex.QueryBuilder {
+  getProvenTxReqsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
     const k = this.toDb(args.trx)
     let q = k('proven_tx_reqs').where(function () {
       this.whereExists(
@@ -156,13 +184,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     if (args.since) q = q.where('updated_at', '>=', this.validateDateForWhere(args.since))
     return q
   }
-  override async getProvenTxReqsForUser(args: sdk.FindForUserSincePagedArgs): Promise<TableProvenTxReq[]> {
+  override async getProvenTxReqsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTxReq[]> {
     const q = this.getProvenTxReqsForUserQuery(args)
     const rs = await q
     return this.validateEntities(rs, undefined, ['notified'])
   }
 
-  getTxLabelMapsForUserQuery(args: sdk.FindForUserSincePagedArgs): Knex.QueryBuilder {
+  getTxLabelMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
     const k = this.toDb(args.trx)
     let q = k('tx_labels_map').whereExists(
       k
@@ -177,13 +205,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return q
   }
-  override async getTxLabelMapsForUser(args: sdk.FindForUserSincePagedArgs): Promise<TableTxLabelMap[]> {
+  override async getTxLabelMapsForUser(args: FindForUserSincePagedArgs): Promise<TableTxLabelMap[]> {
     const q = this.getTxLabelMapsForUserQuery(args)
     const rs = await q
     return this.validateEntities(rs, undefined, ['isDeleted'])
   }
 
-  getOutputTagMapsForUserQuery(args: sdk.FindForUserSincePagedArgs): Knex.QueryBuilder {
+  getOutputTagMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder {
     const k = this.toDb(args.trx)
     let q = k('output_tags_map').whereExists(
       k
@@ -198,22 +226,22 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return q
   }
-  override async getOutputTagMapsForUser(args: sdk.FindForUserSincePagedArgs): Promise<TableOutputTagMap[]> {
+  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: sdk.AuthId, vargs: sdk.ValidListActionsArgs): Promise<ListActionsResult> {
-    if (!auth.userId) throw new sdk.WERR_UNAUTHORIZED()
+  override async listActions(auth: AuthId, vargs: ValidListActionsArgs): Promise<ListActionsResult> {
+    if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listActions(this, auth, vargs)
   }
-  override async listOutputs(auth: sdk.AuthId, vargs: sdk.ValidListOutputsArgs): Promise<ListOutputsResult> {
-    if (!auth.userId) throw new sdk.WERR_UNAUTHORIZED()
+  override async listOutputs(auth: AuthId, vargs: ValidListOutputsArgs): Promise<ListOutputsResult> {
+    if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listOutputs(this, auth, vargs)
   }
 
-  override async insertProvenTx(tx: TableProvenTx, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -221,7 +249,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return tx.provenTxId
   }
 
-  override async insertProvenTxReq(tx: TableProvenTxReq, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -229,7 +257,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return tx.provenTxReqId
   }
 
-  override async insertUser(user: TableUser, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -237,13 +265,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return user.userId
   }
 
-  override async insertCertificateAuth(auth: sdk.AuthId, certificate: TableCertificateX): Promise<number> {
-    if (!auth.userId || (certificate.userId && certificate.userId !== auth.userId)) throw new sdk.WERR_UNAUTHORIZED()
+  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?: sdk.TrxToken): Promise<number> {
+  override 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
@@ -262,12 +290,12 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return certificate.certificateId
   }
 
-  override async insertCertificateField(certificateField: TableCertificateField, trx?: sdk.TrxToken): Promise<void> {
+  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?: sdk.TrxToken): Promise<number> {
+  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)
@@ -275,7 +303,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return basket.basketId
   }
 
-  override async insertTransaction(tx: TableTransaction, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -283,7 +311,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return tx.transactionId
   }
 
-  override async insertCommission(commission: TableCommission, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -291,7 +319,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return commission.commissionId
   }
 
-  override async insertOutput(output: TableOutput, trx?: sdk.TrxToken): Promise<number> {
+  override async insertOutput(output: TableOutput, trx?: TrxToken): Promise<number> {
     try {
       const e = await this.validateEntityForInsert(output, trx)
       if (e.outputId === 0) delete e.outputId
@@ -303,7 +331,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
   }
 
-  override async insertOutputTag(tag: TableOutputTag, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -311,12 +339,12 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return tag.outputTagId
   }
 
-  override async insertOutputTagMap(tagMap: TableOutputTagMap, trx?: sdk.TrxToken): Promise<void> {
+  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?: sdk.TrxToken): Promise<number> {
+  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)
@@ -324,12 +352,12 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return label.txLabelId
   }
 
-  override async insertTxLabelMap(labelMap: TableTxLabelMap, trx?: sdk.TrxToken): Promise<void> {
+  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?: sdk.TrxToken): Promise<number> {
+  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)
@@ -337,7 +365,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return event.id
   }
 
-  override async insertSyncState(syncState: TableSyncState, trx?: sdk.TrxToken): Promise<number> {
+  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)
@@ -349,36 +377,32 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     certificateId: number,
     fieldName: string,
     update: Partial<TableCertificateField>,
-    trx?: sdk.TrxToken
+    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?: sdk.TrxToken): Promise<number> {
+  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?: sdk.TrxToken): Promise<number> {
+  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?: sdk.TrxToken
-  ): Promise<number> {
+  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?: sdk.TrxToken): Promise<number> {
+  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 })
@@ -388,14 +412,14 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     outputId: number,
     tagId: number,
     update: Partial<TableOutputTagMap>,
-    trx?: sdk.TrxToken
+    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?: sdk.TrxToken): Promise<number> {
+  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 })
@@ -404,7 +428,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
   override async updateProvenTxReq(
     id: number | number[],
     update: Partial<TableProvenTxReq>,
-    trx?: sdk.TrxToken
+    trx?: TrxToken
   ): Promise<number> {
     await this.verifyReadyForDatabaseAccess(trx)
     let r: number
@@ -417,17 +441,17 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
         .where({ provenTxReqId: id })
         .update(this.validatePartialForUpdate(update))
     } else {
-      throw new sdk.WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
+      throw new WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
     }
     return r
   }
-  override async updateProvenTx(id: number, update: Partial<TableProvenTx>, trx?: sdk.TrxToken): Promise<number> {
+  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?: sdk.TrxToken): Promise<number> {
+  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 })
@@ -436,7 +460,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
   override async updateTransaction(
     id: number | number[],
     update: Partial<TableTransaction>,
-    trx?: sdk.TrxToken
+    trx?: TrxToken
   ): Promise<number> {
     await this.verifyReadyForDatabaseAccess(trx)
     let r: number
@@ -449,7 +473,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
         .where({ transactionId: id })
         .update(await this.validatePartialForUpdate(update))
     } else {
-      throw new sdk.WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
+      throw new WERR_INVALID_PARAMETER('id', 'transactionId or array of transactionId')
     }
     return r
   }
@@ -457,35 +481,31 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     transactionId: number,
     txLabelId: number,
     update: Partial<TableTxLabelMap>,
-    trx?: sdk.TrxToken
+    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?: sdk.TrxToken): Promise<number> {
+  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?: sdk.TrxToken): Promise<number> {
+  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?: sdk.TrxToken
-  ): Promise<number> {
+  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: sdk.FindPartialSincePagedArgs<T>): Knex.QueryBuilder {
+  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))
@@ -542,29 +562,29 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return q
   }
 
-  findCertificateFieldsQuery(args: sdk.FindCertificateFieldsArgs): Knex.QueryBuilder {
+  findCertificateFieldsQuery(args: FindCertificateFieldsArgs): Knex.QueryBuilder {
     return this.setupQuery('certificate_fields', args)
   }
-  findCertificatesQuery(args: sdk.FindCertificatesArgs): Knex.QueryBuilder {
+  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: sdk.FindCommissionsArgs): Knex.QueryBuilder {
+  findCommissionsQuery(args: FindCommissionsArgs): Knex.QueryBuilder {
     if (args.partial.lockingScript)
-      throw new sdk.WERR_INVALID_PARAMETER(
+      throw new WERR_INVALID_PARAMETER(
         'partial.lockingScript',
         `undefined. Commissions may not be found by lockingScript value.`
       )
     return this.setupQuery('commissions', args)
   }
-  findOutputBasketsQuery(args: sdk.FindOutputBasketsArgs): Knex.QueryBuilder {
+  findOutputBasketsQuery(args: FindOutputBasketsArgs): Knex.QueryBuilder {
     return this.setupQuery('output_baskets', args)
   }
-  findOutputsQuery(args: sdk.FindOutputsArgs, count?: boolean): Knex.QueryBuilder {
+  findOutputsQuery(args: FindOutputsArgs, count?: boolean): Knex.QueryBuilder {
     if (args.partial.lockingScript)
-      throw new sdk.WERR_INVALID_PARAMETER(
+      throw new WERR_INVALID_PARAMETER(
         'args.partial.lockingScript',
         `undefined. Outputs may not be found by lockingScript value.`
       )
@@ -580,22 +600,19 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return q
   }
-  findOutputTagMapsQuery(args: sdk.FindOutputTagMapsArgs): Knex.QueryBuilder {
+  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: sdk.FindOutputTagsArgs): Knex.QueryBuilder {
+  findOutputTagsQuery(args: FindOutputTagsArgs): Knex.QueryBuilder {
     return this.setupQuery('output_tags', args)
   }
-  findProvenTxReqsQuery(args: sdk.FindProvenTxReqsArgs): Knex.QueryBuilder {
+  findProvenTxReqsQuery(args: FindProvenTxReqsArgs): Knex.QueryBuilder {
     if (args.partial.rawTx)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args.partial.rawTx',
-        `undefined. ProvenTxReqs may not be found by rawTx value.`
-      )
+      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. ProvenTxReqs may not be found by rawTx value.`)
     if (args.partial.inputBEEF)
-      throw new sdk.WERR_INVALID_PARAMETER(
+      throw new WERR_INVALID_PARAMETER(
         'args.partial.inputBEEF',
         `undefined. ProvenTxReqs may not be found by inputBEEF value.`
       )
@@ -607,30 +624,24 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return q
   }
-  findProvenTxsQuery(args: sdk.FindProvenTxsArgs): Knex.QueryBuilder {
+  findProvenTxsQuery(args: FindProvenTxsArgs): Knex.QueryBuilder {
     if (args.partial.rawTx)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args.partial.rawTx',
-        `undefined. ProvenTxs may not be found by rawTx value.`
-      )
+      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. ProvenTxs may not be found by rawTx value.`)
     if (args.partial.merklePath)
-      throw new sdk.WERR_INVALID_PARAMETER(
+      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: sdk.FindSyncStatesArgs): Knex.QueryBuilder {
+  findSyncStatesQuery(args: FindSyncStatesArgs): Knex.QueryBuilder {
     return this.setupQuery('sync_states', args)
   }
-  findTransactionsQuery(args: sdk.FindTransactionsArgs, count?: boolean): Knex.QueryBuilder {
+  findTransactionsQuery(args: FindTransactionsArgs, count?: boolean): Knex.QueryBuilder {
     if (args.partial.rawTx)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args.partial.rawTx',
-        `undefined. Transactions may not be found by rawTx value.`
-      )
+      throw new WERR_INVALID_PARAMETER('args.partial.rawTx', `undefined. Transactions may not be found by rawTx value.`)
     if (args.partial.inputBEEF)
-      throw new sdk.WERR_INVALID_PARAMETER(
+      throw new WERR_INVALID_PARAMETER(
         'args.partial.inputBEEF',
         `undefined. Transactions may not be found by inputBEEF value.`
       )
@@ -642,44 +653,41 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return q
   }
-  findTxLabelMapsQuery(args: sdk.FindTxLabelMapsArgs): Knex.QueryBuilder {
+  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: sdk.FindTxLabelsArgs): Knex.QueryBuilder {
+  findTxLabelsQuery(args: FindTxLabelsArgs): Knex.QueryBuilder {
     return this.setupQuery('tx_labels', args)
   }
-  findUsersQuery(args: sdk.FindUsersArgs): Knex.QueryBuilder {
+  findUsersQuery(args: FindUsersArgs): Knex.QueryBuilder {
     return this.setupQuery('users', args)
   }
-  findMonitorEventsQuery(args: sdk.FindMonitorEventsArgs): Knex.QueryBuilder {
+  findMonitorEventsQuery(args: FindMonitorEventsArgs): Knex.QueryBuilder {
     return this.setupQuery('monitor_events', args)
   }
 
-  override async findCertificatesAuth(auth: sdk.AuthId, args: sdk.FindCertificatesArgs): Promise<TableCertificateX[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new sdk.WERR_UNAUTHORIZED()
+  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: sdk.AuthId,
-    args: sdk.FindOutputBasketsArgs
-  ): Promise<TableOutputBasket[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new sdk.WERR_UNAUTHORIZED()
+  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: sdk.AuthId, args: sdk.FindOutputsArgs): Promise<TableOutput[]> {
-    if (!auth.userId || (args.partial.userId && args.partial.userId !== auth.userId)) throw new sdk.WERR_UNAUTHORIZED()
+  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: sdk.FindCertificateFieldsArgs): Promise<TableCertificateField[]> {
+  override async findCertificateFields(args: FindCertificateFieldsArgs): Promise<TableCertificateField[]> {
     return this.validateEntities(await this.findCertificateFieldsQuery(args))
   }
-  override async findCertificates(args: sdk.FindCertificatesArgs): Promise<TableCertificateX[]> {
+  override async findCertificates(args: FindCertificatesArgs): Promise<TableCertificateX[]> {
     const q = this.findCertificatesQuery(args)
     let r: TableCertificateX[] = await q
     r = this.validateEntities(r, undefined, ['isDeleted'])
@@ -695,17 +703,17 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return r
   }
-  override async findCommissions(args: sdk.FindCommissionsArgs): Promise<TableCommission[]> {
+  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: sdk.FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
+  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: sdk.FindOutputsArgs): Promise<TableOutput[]> {
+  override async findOutputs(args: FindOutputsArgs): Promise<TableOutput[]> {
     const q = this.findOutputsQuery(args)
     const r = await q
     if (!args.noScript) {
@@ -715,32 +723,32 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return this.validateEntities(r, undefined, ['spendable', 'change'])
   }
-  override async findOutputTagMaps(args: sdk.FindOutputTagMapsArgs): Promise<TableOutputTagMap[]> {
+  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: sdk.FindOutputTagsArgs): Promise<TableOutputTag[]> {
+  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: sdk.FindProvenTxReqsArgs): Promise<TableProvenTxReq[]> {
+  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: sdk.FindProvenTxsArgs): Promise<TableProvenTx[]> {
+  override async findProvenTxs(args: FindProvenTxsArgs): Promise<TableProvenTx[]> {
     const q = this.findProvenTxsQuery(args)
     const r = await q
     return this.validateEntities(r)
   }
-  override async findSyncStates(args: sdk.FindSyncStatesArgs): Promise<TableSyncState[]> {
+  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: sdk.FindTransactionsArgs): Promise<TableTransaction[]> {
+  override async findTransactions(args: FindTransactionsArgs): Promise<TableTransaction[]> {
     const q = this.findTransactionsQuery(args)
     const r = await q
     if (!args.noRawTx) {
@@ -750,22 +758,22 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
     return this.validateEntities(r, undefined, ['isOutgoing'])
   }
-  override async findTxLabelMaps(args: sdk.FindTxLabelMapsArgs): Promise<TableTxLabelMap[]> {
+  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: sdk.FindTxLabelsArgs): Promise<TableTxLabel[]> {
+  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: sdk.FindUsersArgs): Promise<TableUser[]> {
+  override async findUsers(args: FindUsersArgs): Promise<TableUser[]> {
     const q = this.findUsersQuery(args)
     const r = await q
     return this.validateEntities(r)
   }
-  override async findMonitorEvents(args: sdk.FindMonitorEventsArgs): Promise<TableMonitorEvent[]> {
+  override async findMonitorEvents(args: FindMonitorEventsArgs): Promise<TableMonitorEvent[]> {
     const q = this.findMonitorEventsQuery(args)
     const r = await q
     return this.validateEntities(r, ['when'], undefined)
@@ -777,49 +785,49 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return r[0]['count(*)']
   }
 
-  override async countCertificateFields(args: sdk.FindCertificateFieldsArgs): Promise<number> {
+  override async countCertificateFields(args: FindCertificateFieldsArgs): Promise<number> {
     return await this.getCount(this.findCertificateFieldsQuery(args))
   }
-  override async countCertificates(args: sdk.FindCertificatesArgs): Promise<number> {
+  override async countCertificates(args: FindCertificatesArgs): Promise<number> {
     return await this.getCount(this.findCertificatesQuery(args))
   }
-  override async countCommissions(args: sdk.FindCommissionsArgs): Promise<number> {
+  override async countCommissions(args: FindCommissionsArgs): Promise<number> {
     return await this.getCount(this.findCommissionsQuery(args))
   }
-  override async countOutputBaskets(args: sdk.FindOutputBasketsArgs): Promise<number> {
+  override async countOutputBaskets(args: FindOutputBasketsArgs): Promise<number> {
     return await this.getCount(this.findOutputBasketsQuery(args))
   }
-  override async countOutputs(args: sdk.FindOutputsArgs): Promise<number> {
+  override async countOutputs(args: FindOutputsArgs): Promise<number> {
     return await this.getCount(this.findOutputsQuery(args, true))
   }
-  override async countOutputTagMaps(args: sdk.FindOutputTagMapsArgs): Promise<number> {
+  override async countOutputTagMaps(args: FindOutputTagMapsArgs): Promise<number> {
     return await this.getCount(this.findOutputTagMapsQuery(args))
   }
-  override async countOutputTags(args: sdk.FindOutputTagsArgs): Promise<number> {
+  override async countOutputTags(args: FindOutputTagsArgs): Promise<number> {
     return await this.getCount(this.findOutputTagsQuery(args))
   }
-  override async countProvenTxReqs(args: sdk.FindProvenTxReqsArgs): Promise<number> {
+  override async countProvenTxReqs(args: FindProvenTxReqsArgs): Promise<number> {
     return await this.getCount(this.findProvenTxReqsQuery(args))
   }
-  override async countProvenTxs(args: sdk.FindProvenTxsArgs): Promise<number> {
+  override async countProvenTxs(args: FindProvenTxsArgs): Promise<number> {
     return await this.getCount(this.findProvenTxsQuery(args))
   }
-  override async countSyncStates(args: sdk.FindSyncStatesArgs): Promise<number> {
+  override async countSyncStates(args: FindSyncStatesArgs): Promise<number> {
     return await this.getCount(this.findSyncStatesQuery(args))
   }
-  override async countTransactions(args: sdk.FindTransactionsArgs): Promise<number> {
+  override async countTransactions(args: FindTransactionsArgs): Promise<number> {
     return await this.getCount(this.findTransactionsQuery(args, true))
   }
-  override async countTxLabelMaps(args: sdk.FindTxLabelMapsArgs): Promise<number> {
+  override async countTxLabelMaps(args: FindTxLabelMapsArgs): Promise<number> {
     return await this.getCount(this.findTxLabelMapsQuery(args))
   }
-  override async countTxLabels(args: sdk.FindTxLabelsArgs): Promise<number> {
+  override async countTxLabels(args: FindTxLabelsArgs): Promise<number> {
     return await this.getCount(this.findTxLabelsQuery(args))
   }
-  override async countUsers(args: sdk.FindUsersArgs): Promise<number> {
+  override async countUsers(args: FindUsersArgs): Promise<number> {
     return await this.getCount(this.findUsersQuery(args))
   }
-  override async countMonitorEvents(args: sdk.FindMonitorEventsArgs): Promise<number> {
+  override async countMonitorEvents(args: FindMonitorEventsArgs): Promise<number> {
     return await this.getCount(this.findMonitorEventsQuery(args))
   }
 
@@ -855,11 +863,11 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     }
   }
 
-  override async transaction<T>(scope: (trx: sdk.TrxToken) => Promise<T>, trx?: sdk.TrxToken): Promise<T> {
+  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 sdk.TrxToken
+      const trx = knextrx as TrxToken
       return await scope(trx)
     })
   }
@@ -868,14 +876,14 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * Convert the standard optional `TrxToken` parameter into either a direct knex database instance,
    * or a Knex.Transaction as appropriate.
    */
-  toDb(trx?: sdk.TrxToken) {
+  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?: sdk.TrxToken): Promise<void> {
+  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
 
@@ -896,7 +904,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    *
    * @param trx
    */
-  async verifyReadyForDatabaseAccess(trx?: sdk.TrxToken): Promise<DBType> {
+  async verifyReadyForDatabaseAccess(trx?: TrxToken): Promise<DBType> {
     if (!this._settings) {
       this._settings = await this.readSettings()
     }
@@ -917,12 +925,12 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * Helper to force uniform behavior across database engines.
    * Use to process the update template for entities being updated.
    */
-  validatePartialForUpdate<T extends sdk.EntityTimeStamp>(
+  validatePartialForUpdate<T extends EntityTimeStamp>(
     update: Partial<T>,
     dateFields?: string[],
     booleanFields?: string[]
   ): Partial<T> {
-    if (!this.dbtype) throw new sdk.WERR_INTERNAL('must call verifyReadyForDatabaseAccess first')
+    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)
@@ -955,9 +963,9 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * Helper to force uniform behavior across database engines.
    * Use to process new entities being inserted into the database.
    */
-  async validateEntityForInsert<T extends sdk.EntityTimeStamp>(
+  async validateEntityForInsert<T extends EntityTimeStamp>(
     entity: T,
-    trx?: sdk.TrxToken,
+    trx?: TrxToken,
     dateFields?: string[],
     booleanFields?: string[]
   ): Promise<any> {
@@ -989,7 +997,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return v
   }
 
-  override async getLabelsForTransactionId(transactionId?: number, trx?: sdk.TrxToken): Promise<TableTxLabel[]> {
+  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')
@@ -999,7 +1007,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return this.validateEntities(labels, undefined, ['isDeleted'])
   }
 
-  override async getTagsForOutputId(outputId: number, trx?: sdk.TrxToken): Promise<TableOutputTag[]> {
+  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)
@@ -1008,11 +1016,11 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return this.validateEntities(tags, undefined, ['isDeleted'])
   }
 
-  override async purgeData(params: sdk.PurgeParams, trx?: sdk.TrxToken): Promise<sdk.PurgeResults> {
+  override async purgeData(params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
     return await purgeData(this, params, trx)
   }
 
-  override async reviewStatus(args: { agedLimit: Date; trx?: sdk.TrxToken }): Promise<{ log: string }> {
+  override async reviewStatus(args: { agedLimit: Date; trx?: TrxToken }): Promise<{ log: string }> {
     return await reviewStatus(this, args)
   }
 
@@ -1024,7 +1032,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * - sending (if excludeSending is false)
    */
   async countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {
-    const status: sdk.TransactionStatus[] = ['completed', 'unproven']
+    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})`
@@ -1046,7 +1054,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     excludeSending: boolean,
     transactionId: number
   ): Promise<TableOutput | undefined> {
-    const status: sdk.TransactionStatus[] = ['completed', 'unproven']
+    const status: TransactionStatus[] = ['completed', 'unproven']
     if (!excludeSending) status.push('sending')
     const statusText = status.map(s => `'${s}'`).join(',')
 
@@ -1142,7 +1150,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * Helper to force uniform behavior across database engines.
    * Use to process all individual records with time stamps retreived from database.
    */
-  validateEntity<T extends sdk.EntityTimeStamp>(entity: T, dateFields?: string[], booleanFields?: string[]): T {
+  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) {
@@ -1171,7 +1179,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
    * Use to process all arrays of records with time stamps retreived from database.
    * @returns input `entities` array with contained values validated.
    */
-  validateEntities<T extends sdk.EntityTimeStamp>(entities: T[], dateFields?: string[], booleanFields?: string[]): T[] {
+  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)
     }
@@ -1179,7 +1187,7 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
   }
 
   async adminStats(adminIdentityKey: string): Promise<AdminStatsResult> {
-    if (this.dbtype !== 'MySQL') throw new sdk.WERR_NOT_IMPLEMENTED('adminStats, only MySQL is supported')
+    if (this.dbtype !== 'MySQL') throw new WERR_NOT_IMPLEMENTED('adminStats, only MySQL is supported')
 
     const monitorEvent = verifyOneOrNone(
       await this.findMonitorEvents({