@bopen-io/wallet-toolbox 1.7.18

package/src/storage/methods/processAction.ts

@@ -0,0 +1,420 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import {
+  Beef,
+  Transaction as BsvTransaction,
+  SendWithResult,
+  SendWithResultStatus,
+  WalletLoggerInterface
+} from '@bsv/sdk'
+import { aggregateActionResults } from '../../utility/aggregateResults'
+import { StorageProvider } from '../StorageProvider'
+import {
+  AuthId,
+  ReviewActionResult,
+  StorageProcessActionArgs,
+  StorageProcessActionResults
+} from '../../sdk/WalletStorage.interfaces'
+import { stampLog } from '../../utility/stampLog'
+import {
+  randomBytesBase64,
+  verifyId,
+  verifyInteger,
+  verifyOne,
+  verifyOneOrNone,
+  verifyTruthy
+} from '../../utility/utilityHelpers'
+import { EntityProvenTxReq } from '../schema/entities/EntityProvenTxReq'
+import { WERR_INTERNAL, WERR_INVALID_OPERATION } from '../../sdk/WERR_errors'
+import { TableProvenTxReq } from '../schema/tables/TableProvenTxReq'
+import { TableProvenTx } from '../schema/tables/TableProvenTx'
+import { ProvenTxReqStatus, TransactionStatus } from '../../sdk/types'
+import { parseTxScriptOffsets, TxScriptOffsets } from '../../utility/parseTxScriptOffsets'
+import { TableTransaction } from '../schema/tables/TableTransaction'
+import { TableOutput } from '../schema/tables/TableOutput'
+import { TableCommission } from '../schema/tables/TableCommission'
+import { asArray, asString } from '../../utility/utilityHelpers.noBuffer'
+
+export async function processAction(
+  storage: StorageProvider,
+  auth: AuthId,
+  args: StorageProcessActionArgs
+): Promise<StorageProcessActionResults> {
+  const logger = args.logger
+  logger?.group('storage processAction')
+
+  const userId = verifyId(auth.userId)
+  const r: StorageProcessActionResults = {
+    sendWithResults: undefined
+  }
+
+  let req: EntityProvenTxReq | undefined
+  const txidsOfReqsToShareWithWorld: string[] = [...args.sendWith]
+
+  if (args.isNewTx) {
+    const vargs = await validateCommitNewTxToStorageArgs(storage, userId, args)
+    logger?.log(`validated new tx updates to storage`)
+    ;({ req } = await commitNewTxToStorage(storage, userId, vargs))
+    logger?.log(`committed new tx updates to storage `)
+    if (!req) throw new WERR_INTERNAL()
+    // Add the new txid to sendWith unless there are no others to send and the noSend option is set.
+    if (args.isNoSend && !args.isSendWith) {
+      logger?.log(`noSend txid ${req.txid}`)
+    } else {
+      txidsOfReqsToShareWithWorld.push(req.txid)
+      logger?.log(`sending txid ${req.txid}`)
+    }
+  }
+
+  const { swr, ndr } = await shareReqsWithWorld(
+    storage,
+    userId,
+    txidsOfReqsToShareWithWorld,
+    args.isDelayed,
+    undefined,
+    logger
+  )
+
+  r.sendWithResults = swr
+  r.notDelayedResults = ndr
+
+  logger?.groupEnd()
+
+  return r
+}
+
+export interface GetReqsAndBeefDetail {
+  txid: string
+  req?: TableProvenTxReq
+  proven?: TableProvenTx
+  status: 'readyToSend' | 'alreadySent' | 'error' | 'unknown'
+  error?: string
+}
+
+export interface GetReqsAndBeefResult {
+  beef: Beef
+  details: GetReqsAndBeefDetail[]
+}
+
+export interface PostBeefResultForTxidApi {
+  txid: string
+
+  /**
+   * 'success' - The transaction was accepted for processing
+   */
+  status: 'success' | 'error'
+
+  /**
+   * if true, the transaction was already known to this service. Usually treat as a success.
+   *
+   * Potentially stop posting to additional transaction processors.
+   */
+  alreadyKnown?: boolean
+
+  blockHash?: string
+  blockHeight?: number
+  merklePath?: string
+}
+
+/**
+ * Verifies that all the txids are known reqs with ready-to-share status.
+ * Assigns a batch identifier and updates all the provenTxReqs.
+ * If not isDelayed, triggers an initial attempt to broadcast the batch and returns the results.
+ *
+ * @param storage
+ * @param userId
+ * @param txids
+ * @param isDelayed
+ * @param r Optional. Ignores txids and allows ProvenTxReqs and merged beef to be passed in.
+ */
+export async function shareReqsWithWorld(
+  storage: StorageProvider,
+  userId: number,
+  txids: string[],
+  isDelayed: boolean,
+  r?: GetReqsAndBeefResult,
+  logger?: WalletLoggerInterface
+): Promise<{ swr: SendWithResult[]; ndr: ReviewActionResult[] | undefined }> {
+  let swr: SendWithResult[] = []
+  let ndr: ReviewActionResult[] | undefined = undefined
+
+  if (!r && txids.length < 1) return { swr, ndr }
+
+  // Collect what we know about these sendWith transaction txids from storage.
+  r ||= await storage.getReqsAndBeefToShareWithWorld(txids, [])
+
+  const readyToSendReqs: EntityProvenTxReq[] = []
+  for (const getReq of r.details) {
+    let status: SendWithResultStatus = 'failed'
+    if (getReq.status === 'alreadySent') status = 'unproven'
+    else if (getReq.status === 'readyToSend') {
+      status = 'sending'
+      readyToSendReqs.push(new EntityProvenTxReq(getReq.req!))
+    }
+    swr.push({
+      txid: getReq.txid,
+      status
+    })
+  }
+
+  // Filter original txids down to reqIds that are available and need sending
+  const readyToSendReqIds = readyToSendReqs.map(r => r.id)
+  const transactionIds = readyToSendReqs.map(r => r.notify.transactionIds || []).flat()
+
+  // If there are reqs to send, verify that we have a valid aggregate beef for them.
+  // If isDelayed, this (or a different beef) will have to be rebuilt at the time of sending.
+  if (readyToSendReqs.length > 0) {
+    const beefIsValid = await r.beef.verify(await storage.getServices().getChainTracker())
+    if (!beefIsValid) {
+      logger?.error(`VERIFY FALSE BEEF: ${r.beef.toLogString()}`)
+      throw new WERR_INTERNAL(`merged Beef failed validation.`)
+    }
+    logger?.log(`beef is valid`)
+  }
+
+  // Set req batch property for the reqs being sent
+  // If delayed, also bump status to 'unsent' and we're done here
+  const batch = txids.length > 1 ? randomBytesBase64(16) : undefined
+  if (isDelayed) {
+    // Just bump the req status to 'unsent' to enable background sending...
+    if (readyToSendReqIds.length > 0) {
+      await storage.transaction(async trx => {
+        await storage.updateProvenTxReq(readyToSendReqIds, { status: 'unsent', batch }, trx)
+        await storage.updateTransaction(transactionIds, { status: 'sending' }, trx)
+      })
+    }
+    return { swr, ndr }
+  }
+
+  if (readyToSendReqIds.length < 1) {
+    return { swr, ndr }
+  }
+
+  if (batch) {
+    // Keep batch values in sync...
+    for (const req of readyToSendReqs) req.batch = batch
+    await storage.updateProvenTxReq(readyToSendReqIds, { batch })
+  }
+
+  //
+  // Handle the NON-DELAYED-SEND-NOW case
+  //
+  const prtn = await storage.attemptToPostReqsToNetwork(readyToSendReqs, undefined, logger)
+
+  const { swr: swrRes, rar } = await aggregateActionResults(storage, swr, prtn)
+  return { swr: swrRes, ndr: rar }
+}
+
+interface ReqTxStatus {
+  req: ProvenTxReqStatus
+  tx: TransactionStatus
+}
+
+interface ValidCommitNewTxToStorageArgs {
+  // validated input args
+
+  reference: string
+  txid: string
+  rawTx: number[]
+  isNoSend: boolean
+  isDelayed: boolean
+  isSendWith: boolean
+  log?: string
+
+  // validated dependent args
+
+  tx: BsvTransaction
+  txScriptOffsets: TxScriptOffsets
+  transactionId: number
+  transaction: TableTransaction
+  inputOutputs: TableOutput[]
+  outputOutputs: TableOutput[]
+  commission: TableCommission | undefined
+  beef: Beef
+
+  req: EntityProvenTxReq
+  outputUpdates: { id: number; update: Partial<TableOutput> }[]
+  transactionUpdate: Partial<TableTransaction>
+  postStatus?: ReqTxStatus
+}
+
+async function validateCommitNewTxToStorageArgs(
+  storage: StorageProvider,
+  userId: number,
+  params: StorageProcessActionArgs
+): Promise<ValidCommitNewTxToStorageArgs> {
+  if (!params.reference || !params.txid || !params.rawTx)
+    throw new WERR_INVALID_OPERATION('One or more expected params are undefined.')
+  let tx: BsvTransaction
+  try {
+    tx = BsvTransaction.fromBinary(params.rawTx)
+  } catch (e: unknown) {
+    throw new WERR_INVALID_OPERATION('Parsing serialized transaction failed.')
+  }
+  if (params.txid !== tx.id('hex'))
+    throw new WERR_INVALID_OPERATION(`Hash of serialized transaction doesn't match expected txid`)
+  if (!(await storage.getServices()).nLockTimeIsFinal(tx)) {
+    throw new WERR_INVALID_OPERATION(`This transaction is not final.
+         Ensure that the transaction meets the rules for being a finalized
+         which can be found at https://wiki.bitcoinsv.io/index.php/NLocktime_and_nSequence`)
+  }
+  const txScriptOffsets = parseTxScriptOffsets(params.rawTx)
+  const transaction = verifyOne(
+    await storage.findTransactions({
+      partial: { userId, reference: params.reference }
+    })
+  )
+  if (!transaction.isOutgoing) throw new WERR_INVALID_OPERATION('isOutgoing is not true')
+  if (!transaction.inputBEEF) throw new WERR_INVALID_OPERATION()
+  const beef = Beef.fromBinary(asArray(transaction.inputBEEF))
+  // TODO: Could check beef validates transaction inputs...
+  // Transaction must have unsigned or unprocessed status
+  if (transaction.status !== 'unsigned' && transaction.status !== 'unprocessed')
+    throw new WERR_INVALID_OPERATION(`invalid transaction status ${transaction.status}`)
+  const transactionId = verifyId(transaction.transactionId)
+  const outputOutputs = await storage.findOutputs({
+    partial: { userId, transactionId }
+  })
+  const inputOutputs = await storage.findOutputs({
+    partial: { userId, spentBy: transactionId }
+  })
+
+  const commission = verifyOneOrNone(await storage.findCommissions({ partial: { transactionId, userId } }))
+  if (storage.commissionSatoshis > 0) {
+    // A commission is required...
+    if (!commission) throw new WERR_INTERNAL()
+    const commissionValid = tx.outputs.some(
+      x => x.satoshis === commission.satoshis && x.lockingScript.toHex() === asString(commission.lockingScript!)
+    )
+    if (!commissionValid)
+      throw new WERR_INVALID_OPERATION('Transaction did not include an output to cover service fee.')
+  }
+
+  const req = EntityProvenTxReq.fromTxid(params.txid, params.rawTx, transaction.inputBEEF)
+  req.addNotifyTransactionId(transactionId)
+
+  // "Processing" a transaction is the final step of creating a new one.
+  // If it is to be sent to the network directly (prior to return from processAction),
+  // then there is status pre-send and post-send.
+  // Otherwise there is no post-send status.
+  // Note that isSendWith trumps isNoSend, e.g. isNoSend && !isSendWith
+  //
+  // Determine what status the req and transaction should have pre- at the end of processing.
+  //                           Pre-Status (to newReq/newTx)     Post-Status (to all sent reqs/txs)
+  //                           req         tx                   req                 tx
+  // isNoSend                  noSend      noSend
+  // !isNoSend && isDelayed    unsent      unprocessed
+  // !isNoSend && !isDelayed   unprocessed unprocessed          sending/unmined     sending/unproven      This is the only case that sends immediately.
+  let postStatus: ReqTxStatus | undefined = undefined
+  let status: ReqTxStatus
+  if (params.isNoSend && !params.isSendWith) status = { req: 'nosend', tx: 'nosend' }
+  else if (!params.isNoSend && params.isDelayed) status = { req: 'unsent', tx: 'unprocessed' }
+  else if (!params.isNoSend && !params.isDelayed) {
+    status = { req: 'unprocessed', tx: 'unprocessed' }
+    postStatus = { req: 'unmined', tx: 'unproven' }
+  } else throw new WERR_INTERNAL('logic error')
+
+  req.status = status.req
+  const vargs: ValidCommitNewTxToStorageArgs = {
+    reference: params.reference,
+    txid: params.txid,
+    rawTx: params.rawTx,
+    isSendWith: !!params.sendWith && params.sendWith.length > 0,
+    isDelayed: params.isDelayed,
+    isNoSend: params.isNoSend,
+    // Properties with values added during validation.
+    tx,
+    txScriptOffsets,
+    transactionId,
+    transaction,
+    inputOutputs,
+    outputOutputs,
+    commission,
+    beef,
+    req,
+    outputUpdates: [],
+    // update txid, status in transactions table and drop rawTransaction value
+    transactionUpdate: {
+      txid: params.txid,
+      rawTx: undefined,
+      inputBEEF: undefined,
+      status: status.tx
+    },
+    postStatus
+  }
+
+  // update outputs with txid, script offsets and lengths, drop long output scripts from outputs table
+  // outputs spendable will be updated for change to true and all others to !!o.tracked when tx has been broadcast
+  // MAX_OUTPUTSCRIPT_LENGTH is limit for scripts left in outputs table
+  for (const o of vargs.outputOutputs) {
+    const vout = verifyInteger(o.vout)
+    const offset = vargs.txScriptOffsets.outputs[vout]
+    const rawTxScript = asString(vargs.rawTx.slice(offset.offset, offset.offset + offset.length))
+    if (o.lockingScript && rawTxScript !== asString(o.lockingScript))
+      throw new WERR_INVALID_OPERATION(
+        `rawTx output locking script for vout ${vout} not equal to expected output script.`
+      )
+    if (tx.outputs[vout].lockingScript.toHex() !== rawTxScript)
+      throw new WERR_INVALID_OPERATION(
+        `parsed transaction output locking script for vout ${vout} not equal to expected output script.`
+      )
+    const update: Partial<TableOutput> = {
+      txid: vargs.txid,
+      spendable: true, // spendability is gated by transaction status. Remains true until the output is spent.
+      scriptLength: offset.length,
+      scriptOffset: offset.offset
+    }
+    if (offset.length > (await storage.getSettings()).maxOutputScript)
+      // Remove long lockingScript data from outputs table, will be read from rawTx in proven_tx or proven_tx_reqs tables.
+      update.lockingScript = undefined
+    vargs.outputUpdates.push({ id: o.outputId!, update })
+  }
+
+  return vargs
+}
+
+export interface CommitNewTxResults {
+  req: EntityProvenTxReq
+  log?: string
+}
+
+async function commitNewTxToStorage(
+  storage: StorageProvider,
+  userId: number,
+  vargs: ValidCommitNewTxToStorageArgs
+): Promise<CommitNewTxResults> {
+  let log = vargs.log
+
+  log = stampLog(log, `start storage commitNewTxToStorage`)
+
+  let req: EntityProvenTxReq | undefined
+
+  await storage.transaction(async trx => {
+    log = stampLog(log, `... storage commitNewTxToStorage storage transaction start`)
+
+    // Create initial 'nosend' proven_tx_req record to store signed, valid rawTx and input beef
+    req = await vargs.req.insertOrMerge(storage, trx)
+
+    log = stampLog(log, `... storage commitNewTxToStorage req inserted`)
+
+    for (const ou of vargs.outputUpdates) {
+      await storage.updateOutput(ou.id, ou.update, trx)
+    }
+
+    log = stampLog(log, `... storage commitNewTxToStorage outputs updated`)
+
+    await storage.updateTransaction(vargs.transactionId, vargs.transactionUpdate, trx)
+
+    log = stampLog(log, `... storage commitNewTxToStorage storage transaction end`)
+  })
+
+  log = stampLog(log, `... storage commitNewTxToStorage storage transaction await done`)
+
+  const r: CommitNewTxResults = {
+    req: verifyTruthy(req),
+    log
+  }
+
+  log = stampLog(log, `end storage commitNewTxToStorage`)
+
+  return r
+}

package/src/storage/methods/purgeData.ts

@@ -0,0 +1,251 @@
+import { Beef } from '@bsv/sdk'
+import { Knex } from 'knex'
+import { StorageKnex } from '../StorageKnex'
+import { PurgeParams, PurgeResults, StorageGetBeefOptions, TrxToken } from '../../sdk/WalletStorage.interfaces'
+import { WalletError } from '../../sdk/WalletError'
+import { TableTransaction } from '../schema/tables/TableTransaction'
+import { TableOutput } from '../schema/tables/TableOutput'
+import { TableOutputTagMap } from '../schema/tables/TableOutputTagMap'
+import { TableTxLabelMap } from '../schema/tables/TableTxLabelMap'
+import { TableCommission } from '../schema/tables/TableCommission'
+
+export async function purgeData(storage: StorageKnex, params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
+  const r: PurgeResults = { count: 0, log: '' }
+  const defaultAge = 1000 * 60 * 60 * 24 * 14
+
+  const runPurgeQuery = async <T extends object>(pq: PurgeQuery): Promise<void> => {
+    try {
+      pq.sql = pq.q.toString()
+      const count = await pq.q
+      if (count > 0) {
+        r.count += count
+        r.log += `${count} ${pq.log}\n`
+      }
+    } catch (eu: unknown) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const e = WalletError.fromUnknown(eu)
+      throw eu
+    }
+  }
+
+  if (params.purgeCompleted) {
+    const age = params.purgeCompletedAge || defaultAge
+    const before = toSqlWhereDate(new Date(Date.now() - age))
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const qs: PurgeQuery[] = []
+
+    // select * from transactions where updated_at < '2024-08-20' and status = 'completed' and not provenTxId is null and (not truncatedExternalInputs is null or not beef is null or not rawTx is null)
+    qs.push({
+      log: 'conpleted transactions purged of transient data',
+      q: storage
+        .toDb(trx)('transactions')
+        .update({
+          inputBEEF: null,
+          rawTx: null
+        })
+        .where('updated_at', '<', before)
+        .where('status', 'completed')
+        .whereNotNull('provenTxId')
+        .where(function () {
+          this.orWhereNotNull('inputBEEF')
+          this.orWhereNotNull('rawTx')
+        })
+    })
+
+    const completedReqs = await storage
+      .toDb(trx)<{ provenTxReqId: number }>('proven_tx_reqs')
+      .select('provenTxReqId')
+      .where('updated_at', '<', before)
+      .where('status', 'completed')
+      .whereNotNull('provenTxId')
+      .where('notified', 1)
+    const completedReqIds = completedReqs.map(o => o.provenTxReqId)
+
+    if (completedReqIds.length > 0) {
+      qs.push({
+        log: 'completed proven_tx_reqs deleted',
+        q: storage.toDb(trx)('proven_tx_reqs').whereIn('provenTxReqId', completedReqIds).delete()
+      })
+    }
+
+    for (const q of qs) await runPurgeQuery(q)
+  }
+
+  if (params.purgeFailed) {
+    const age = params.purgeFailedAge || defaultAge
+    const before = toSqlWhereDate(new Date(Date.now() - age))
+
+    const qs: PurgeQuery[] = []
+
+    const failedTxsQ = storage
+      .toDb(trx)<{ transactionId: number }>('transactions')
+      .select('transactionId')
+      .where('updated_at', '<', before)
+      .where('status', 'failed')
+    const txs = await failedTxsQ
+    const failedTxIds = txs.map(tx => tx.transactionId)
+
+    await deleteTransactions(failedTxIds, qs, 'failed', true)
+
+    const invalidReqs = await storage
+      .toDb(trx)<{ provenTxReqId: number }>('proven_tx_reqs')
+      .select('provenTxReqId')
+      .where('updated_at', '<', before)
+      .where('status', 'invalid')
+    const invalidReqIds = invalidReqs.map(o => o.provenTxReqId)
+    if (invalidReqIds.length > 0)
+      qs.push({
+        log: 'invalid proven_tx_reqs deleted',
+        q: storage.toDb(trx)('proven_tx_reqs').whereIn('provenTxReqId', invalidReqIds).delete()
+      })
+
+    const doubleSpendReqs = await storage
+      .toDb(trx)<{ provenTxReqId: number }>('proven_tx_reqs')
+      .select('provenTxReqId')
+      .where('updated_at', '<', before)
+      .where('status', 'doubleSpend')
+    const doubleSpendReqIds = doubleSpendReqs.map(o => o.provenTxReqId)
+    if (doubleSpendReqIds.length > 0)
+      qs.push({
+        log: 'doubleSpend proven_tx_reqs deleted',
+        q: storage.toDb(trx)('proven_tx_reqs').whereIn('provenTxReqId', doubleSpendReqIds).delete()
+      })
+
+    for (const q of qs) await runPurgeQuery(q)
+  }
+
+  if (params.purgeSpent) {
+    const age = params.purgeSpentAge || defaultAge
+    const before = toSqlWhereDate(new Date(Date.now() - age))
+
+    const beef = new Beef()
+    const utxos = await storage.findOutputs({
+      partial: { spendable: true },
+      txStatus: ['sending', 'unproven', 'completed', 'nosend']
+    })
+    for (const utxo of utxos) {
+      // Figure out all the txids required to prove the validity of this utxo and merge proofs into beef.
+      const options: StorageGetBeefOptions = {
+        mergeToBeef: beef,
+        ignoreServices: true
+      }
+      if (utxo.txid) await storage.getBeefForTransaction(utxo.txid, options)
+    }
+    const proofTxids: Record<string, boolean> = {}
+    for (const btx of beef.txs) proofTxids[btx.txid] = true
+
+    let qs: PurgeQuery[] = []
+
+    const spentTxsQ = storage
+      .toDb(trx)<TableTransaction>('transactions')
+      .where('updated_at', '<', before)
+      .where('status', 'completed')
+      .whereRaw(
+        `not exists(select outputId from outputs as o where o.transactionId = transactions.transactionId and o.spendable = 1)`
+      )
+    const txs: TableTransaction[] = await spentTxsQ
+    // Save any spent txid still needed to prove a utxo:
+    const nptxs = txs.filter(t => !proofTxids[t.txid || ''])
+    let spentTxIds = nptxs.map(tx => tx.transactionId)
+
+    if (spentTxIds.length > 0) {
+      const update: Partial<TableOutput> = {
+        spentBy: null as unknown as undefined
+      }
+      qs.push({
+        log: 'spent outputs no longer tracked by spentBy',
+        q: storage
+          .toDb(trx)<TableOutput>('outputs')
+          .update(storage.validatePartialForUpdate(update, undefined, ['spendable']))
+          .where('spendable', false)
+          .whereIn('spentBy', spentTxIds)
+      })
+
+      await deleteTransactions(spentTxIds, qs, 'spent', false)
+
+      for (const q of qs) await runPurgeQuery(q)
+    }
+  }
+
+  // Delete proven_txs no longer referenced by remaining transactions.
+  const qs: PurgeQuery[] = []
+  qs.push({
+    log: 'orphan proven_txs deleted',
+    q: storage
+      .toDb(trx)('proven_txs')
+      .whereRaw(
+        `not exists(select * from transactions as t where t.txid = proven_txs.txid or t.provenTxId = proven_txs.provenTxId)`
+      )
+      .whereRaw(
+        `not exists(select * from proven_tx_reqs as r where r.txid = proven_txs.txid or r.provenTxId = proven_txs.provenTxId)`
+      )
+      .delete()
+  })
+  for (const q of qs) await runPurgeQuery(q)
+
+  return r
+
+  async function deleteTransactions(
+    transactionIds: number[],
+    qs: PurgeQuery[],
+    reason: string,
+    markNotSpentBy: boolean
+  ) {
+    if (transactionIds.length > 0) {
+      const outputs = await storage
+        .toDb(trx)<{ outputId: number }>('outputs')
+        .select('outputId')
+        .whereIn('transactionId', transactionIds)
+      const outputIds = outputs.map(o => o.outputId)
+      if (outputIds.length > 0) {
+        qs.push({
+          log: `${reason} output_tags_map deleted`,
+          q: storage.toDb(trx)<TableOutputTagMap>('output_tags_map').whereIn('outputId', outputIds).delete()
+        })
+        qs.push({
+          log: `${reason} outputs deleted`,
+          q: storage.toDb(trx)<TableOutput>('outputs').whereIn('outputId', outputIds).delete()
+        })
+      }
+
+      qs.push({
+        log: `${reason} tx_labels_map deleted`,
+        q: storage.toDb(trx)<TableTxLabelMap>('tx_labels_map').whereIn('transactionId', transactionIds).delete()
+      })
+
+      qs.push({
+        log: `${reason} commissions deleted`,
+        q: storage.toDb(trx)<TableCommission>('commissions').whereIn('transactionId', transactionIds).delete()
+      })
+
+      if (markNotSpentBy) {
+        qs.push({
+          log: 'unspent outputs updated to spendable',
+          q: storage
+            .toDb(trx)<TableOutput>('outputs')
+            .update({ spendable: true, spentBy: null as unknown as undefined })
+            .whereIn('spentBy', transactionIds)
+        })
+      }
+
+      qs.push({
+        log: `${reason} transactions deleted`,
+        q: storage.toDb(trx)<TableTransaction>('transactions').whereIn('transactionId', transactionIds).delete()
+      })
+    }
+  }
+}
+
+interface PurgeQuery {
+  q: Knex.QueryBuilder<any, number>
+  sql?: string
+  log: string
+}
+
+function toSqlWhereDate(d: Date): string {
+  let s = d.toISOString()
+  s = s.replace('T', ' ')
+  s = s.replace('Z', '')
+  return s
+}

package/src/storage/methods/purgeDataIdb.ts

@@ -0,0 +1,10 @@
+import { Beef } from '@bsv/sdk'
+import { Knex } from 'knex'
+import { StorageIdb } from '../StorageIdb'
+import { PurgeParams, PurgeResults, TrxToken } from '../../sdk/WalletStorage.interfaces'
+
+export async function purgeDataIdb(storage: StorageIdb, params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
+  const r: PurgeResults = { count: 0, log: '' }
+  // TODO: implement purgeDataIdb
+  return r
+}