@bopen-io/wallet-toolbox 1.7.18

package/src/monitor/tasks/TaskReviewStatus.ts

@@ -0,0 +1,48 @@
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+
+/**
+ * Notify Transaction records of changes in ProvenTxReq records they may have missed.
+ *
+ * The `notified` property flags reqs that do not need to be checked.
+ *
+ * Looks for aged Transactions with provenTxId with status != 'completed', sets status to 'completed'.
+ *
+ * Looks for reqs with 'invalid' status that have corresonding transactions with status other than 'failed'.
+ */
+export class TaskReviewStatus extends WalletMonitorTask {
+  static taskName = 'ReviewStatus'
+
+  /**
+   * Set to true to trigger running this task
+   */
+  static checkNow = false
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = 1000 * 60 * 15,
+    public agedMsecs = 1000 * 60 * 5
+  ) {
+    super(monitor, TaskReviewStatus.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    return {
+      run: this.triggerMsecs > 0 && nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs
+    }
+  }
+
+  async runTask(): Promise<string> {
+    let log = ''
+
+    const agedLimit = new Date(Date.now() - this.agedMsecs)
+    const r = await this.storage.runAsStorageProvider(async sp => {
+      const r = await sp.reviewStatus({ agedLimit })
+      return r
+    })
+
+    if (r.log.length > 0) log += `${r.log}`
+
+    return log
+  }
+}

package/src/monitor/tasks/TaskSendWaiting.ts

@@ -0,0 +1,122 @@
+import { ReviewActionResult, SendWithResult } from '@bsv/sdk'
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+import { attemptToPostReqsToNetwork } from '../../storage/methods/attemptToPostReqsToNetwork'
+import { aggregateActionResults } from '../../utility/aggregateResults'
+import { ProvenTxReqStatus } from '../../sdk/types'
+import { verifyTruthy } from '../../utility/utilityHelpers'
+import { TableProvenTxReq } from '../../storage/schema/tables/TableProvenTxReq'
+import { EntityProvenTxReq } from '../../storage/schema/entities/EntityProvenTxReq'
+
+export class TaskSendWaiting extends WalletMonitorTask {
+  static taskName = 'SendWaiting'
+
+  lastSendingRunMsecsSinceEpoch: number | undefined
+  includeSending: boolean = true
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = Monitor.oneSecond * 8,
+    public agedMsecs = Monitor.oneSecond * 7,
+    public sendingMsecs = Monitor.oneMinute * 5
+  ) {
+    super(monitor, TaskSendWaiting.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    this.includeSending =
+      !this.lastSendingRunMsecsSinceEpoch || nowMsecsSinceEpoch > this.lastSendingRunMsecsSinceEpoch + this.sendingMsecs
+    if (this.includeSending) this.lastSendingRunMsecsSinceEpoch = nowMsecsSinceEpoch
+    return {
+      run: nowMsecsSinceEpoch > this.lastRunMsecsSinceEpoch + this.triggerMsecs
+    }
+  }
+
+  async runTask(): Promise<string> {
+    let log = ''
+    const limit = 100
+    let offset = 0
+    const agedLimit = new Date(Date.now() - this.agedMsecs)
+    const status: ProvenTxReqStatus[] = this.includeSending ? ['unsent', 'sending'] : ['unsent']
+    for (;;) {
+      let reqs = await this.storage.findProvenTxReqs({
+        partial: {},
+        status,
+        paged: { limit, offset }
+      })
+      const count = reqs.length
+      if (reqs.length === 0) break
+      log += `${reqs.length} reqs with status ${status.join(' or ')}\n`
+      const agedReqs = reqs.filter(req => verifyTruthy(req.updated_at) < agedLimit)
+      log += `  Of those reqs, ${agedReqs.length} where last updated before ${agedLimit.toISOString()}.\n`
+      log += await this.processUnsent(agedReqs, 2)
+      if (count < limit) break
+      offset += limit
+    }
+    return log
+  }
+
+  /**
+   * Process an array of 'unsent' status table.ProvenTxReq
+   *
+   * Send rawTx to transaction processor(s), requesting proof callbacks when possible.
+   *
+   * Set status 'invalid' if req is invalid.
+   *
+   * Set status to 'callback' on successful network submission with callback service.
+   *
+   * Set status to 'unmined' on successful network submission without callback service.
+   *
+   * Add mapi responses to database table if received.
+   *
+   * Increments attempts if sending was attempted.
+   *
+   * @param reqApis
+   */
+  async processUnsent(reqApis: TableProvenTxReq[], indent = 0): Promise<string> {
+    let log = ''
+    for (let i = 0; i < reqApis.length; i++) {
+      const reqApi = reqApis[i]
+      log += ' '.repeat(indent)
+      log += `${i} reqId=${reqApi.provenTxReqId} attempts=${reqApi.attempts} txid=${reqApi.txid}: \n`
+      if (reqApi.status !== 'unsent' && reqApi.status !== 'sending') {
+        log += `  status now ${reqApi.status}\n`
+        continue
+      }
+      const req = new EntityProvenTxReq(reqApi)
+      const reqs: EntityProvenTxReq[] = []
+      if (req.batch) {
+        // Make sure wew process entire batch together for efficient beef generation
+        const batchReqApis = await this.storage.findProvenTxReqs({
+          partial: { batch: req.batch, status: 'unsent' }
+        })
+        for (const bra of batchReqApis) {
+          // Remove any matching batchReqApis from reqApis
+          const index = reqApis.findIndex(ra => ra.provenTxReqId === bra.provenTxReqId)
+          if (index > -1) reqApis.slice(index, index + 1)
+          // And add to reqs being processed now:
+          reqs.push(new EntityProvenTxReq(bra))
+        }
+      } else {
+        // Just a single non-batched req...
+        reqs.push(req)
+      }
+
+      const r = await this.storage.runAsStorageProvider(async sp => {
+        return attemptToPostReqsToNetwork(sp, reqs)
+      })
+
+      if (this.monitor.onTransactionBroadcasted) {
+        const rar = await this.storage.runAsStorageProvider(async sp => {
+          const ars: SendWithResult[] = [{ txid: req.txid, status: 'sending' }]
+          const { rar } = await aggregateActionResults(sp, ars, r)
+          return rar
+        })
+        this.monitor.callOnBroadcastedTransaction(rar[0])
+      }
+
+      log += r.log
+    }
+    return log
+  }
+}

package/src/monitor/tasks/TaskSyncWhenIdle.ts

@@ -0,0 +1,26 @@
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+
+export class TaskSyncWhenIdle extends WalletMonitorTask {
+  static taskName = 'SyncWhenIdle'
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = 1000 * 60 * 1
+  ) {
+    super(monitor, TaskSyncWhenIdle.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    const s = this.storage
+
+    const run = false
+
+    return { run }
+  }
+
+  async runTask(): Promise<string> {
+    // TODO...
+    return ''
+  }
+}

package/src/monitor/tasks/TaskUnFail.ts

@@ -0,0 +1,151 @@
+import { Transaction, Utils } from '@bsv/sdk'
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+import { TableProvenTxReq } from '../../storage/schema/tables'
+import { EntityProvenTxReq } from '../../storage/schema/entities'
+import { StorageProvider } from '../../index.client'
+
+/**
+ * Setting provenTxReq status to 'unfail' when 'invalid' will attempt to find a merklePath, and if successful:
+ *
+ * 1. set the req status to 'unmined'
+ * 2. set the referenced txs to 'unproven'
+ * 3. determine if any inputs match user's existing outputs and if so update spentBy and spendable of those outputs.
+ * 4. set the txs outputs to spendable
+ *
+ * If it fails (to find a merklePath), returns the req status to 'invalid'.
+ */
+export class TaskUnFail extends WalletMonitorTask {
+  static taskName = 'UnFail'
+
+  /**
+   * Set to true to trigger running this task
+   */
+  static checkNow = false
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = Monitor.oneMinute * 10
+  ) {
+    super(monitor, TaskUnFail.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    return {
+      run:
+        TaskUnFail.checkNow ||
+        (this.triggerMsecs > 0 && nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs)
+    }
+  }
+
+  async runTask(): Promise<string> {
+    let log = ''
+    TaskUnFail.checkNow = false
+
+    const limit = 100
+    let offset = 0
+    for (;;) {
+      const reqs = await this.storage.findProvenTxReqs({
+        partial: {},
+        status: ['unfail'],
+        paged: { limit, offset }
+      })
+      if (reqs.length === 0) break
+      log += `${reqs.length} reqs with status 'unfail'\n`
+      const r = await this.unfail(reqs, 2)
+      log += `${r.log}\n`
+      //console.log(log);
+      if (reqs.length < limit) break
+      offset += limit
+    }
+
+    return log
+  }
+
+  async unfail(reqs: TableProvenTxReq[], indent = 0): Promise<{ log: string }> {
+    let log = ''
+    for (const reqApi of reqs) {
+      const req = new EntityProvenTxReq(reqApi)
+      log += ' '.repeat(indent)
+      log += `reqId ${reqApi.provenTxReqId} txid ${reqApi.txid}: `
+      const r = await this.monitor.services.getMerklePath(req.txid)
+      if (r.merklePath) {
+        // 1. set the req status to 'unmined'
+        req.status = 'unmined'
+        req.attempts = 0
+        log += `unfailed. status is now 'unmined'\n`
+        log += await this.unfailReq(req, indent + 2)
+      } else {
+        req.status = 'invalid'
+        log += `returned to status 'invalid'\n`
+      }
+      await req.updateStorageDynamicProperties(this.storage)
+    }
+    return { log }
+  }
+
+  /**
+   * 2. set the referenced txs to 'unproven'
+   * 3. determine if any inputs match user's existing outputs and if so update spentBy and spendable of those outputs.
+   * 4. set the txs outputs to spendable
+   *
+   * @param req
+   * @param indent
+   * @returns
+   */
+  async unfailReq(req: EntityProvenTxReq, indent: number): Promise<string> {
+    let log = ''
+
+    const storage = this.storage
+    const services = this.monitor.services
+
+    const txIds = req.notify.transactionIds || []
+    for (const id of txIds) {
+      const bsvtx = Transaction.fromBinary(req.rawTx)
+      await this.storage.runAsStorageProvider(async sp => {
+        const spk = sp as StorageProvider
+        const tx = await sp.findTransactionById(id, undefined, true)
+        if (!tx) {
+          log += ' '.repeat(indent) + `transaction ${id} was not found\n`
+          return
+        }
+        await sp.updateTransaction(tx.transactionId, { status: 'unproven' })
+        tx.status = 'unproven'
+        log += ' '.repeat(indent) + `transaction ${id} status is now 'unproven'\n`
+        let vin = -1
+        for (const bi of bsvtx.inputs) {
+          vin++
+          const is = await sp.findOutputs({
+            partial: { userId: tx.userId, txid: bi.sourceTXID!, vout: bi.sourceOutputIndex }
+          })
+          if (is.length !== 1) {
+            log += ' '.repeat(indent + 2) + `input ${vin} not matched to user's outputs\n`
+          } else {
+            const oi = is[0]
+            log +=
+              ' '.repeat(indent + 2) +
+              `input ${vin} matched to output ${oi.outputId} updated spentBy ${tx.transactionId}\n`
+            await sp.updateOutput(oi.outputId, { spendable: false, spentBy: tx.transactionId })
+          }
+        }
+        const outputs = await sp.findOutputs({ partial: { userId: tx.userId, transactionId: tx.transactionId } })
+        for (const o of outputs) {
+          await spk.validateOutputScript(o)
+          if (!o.lockingScript) {
+            log += ' '.repeat(indent + 2) + `output ${o.outputId} does not have a valid locking script\n`
+          } else {
+            const isUtxo = await services.isUtxo(o)
+            if (isUtxo !== o.spendable) {
+              log += ' '.repeat(indent + 2) + `output ${o.outputId} set to ${isUtxo ? 'spendable' : 'spent'}\n`
+              await sp.updateOutput(o.outputId, { spendable: isUtxo })
+            } else {
+              log += ' '.repeat(indent + 2) + `output ${o.outputId} unchanged\n`
+            }
+          }
+        }
+      })
+    }
+
+    return log
+  }
+}

package/src/monitor/tasks/WalletMonitorTask.ts

@@ -0,0 +1,47 @@
+import { MonitorStorage, Monitor } from '../Monitor'
+
+/**
+ * A monitor task performs some periodic or state triggered maintenance function
+ * on the data managed by a wallet (Bitcoin UTXO manager, aka wallet)
+ *
+ * The monitor maintains a collection of tasks.
+ *
+ * It runs each task's non-asynchronous trigger to determine if the runTask method needs to run.
+ *
+ * Tasks that need to be run are run consecutively by awaiting their async runTask override method.
+ *
+ * The monitor then waits a fixed interval before repeating...
+ *
+ * Tasks may use the monitor_events table to persist their execution history.
+ * This is done by accessing the wathman.storage object.
+ */
+
+export abstract class WalletMonitorTask {
+  /**
+   * Set by monitor each time runTask completes
+   */
+  lastRunMsecsSinceEpoch = 0
+
+  storage: MonitorStorage
+
+  constructor(
+    public monitor: Monitor,
+    public name: string
+  ) {
+    this.storage = monitor.storage
+  }
+
+  /**
+   * Override to handle async task setup configuration.
+   *
+   * Called before first call to `trigger`
+   */
+  async asyncSetup(): Promise<void> {}
+
+  /**
+   * Return true if `runTask` needs to be called now.
+   */
+  abstract trigger(nowMsecsSinceEpoch: number): { run: boolean }
+
+  abstract runTask(): Promise<string>
+}

package/src/sdk/CertOpsWallet.ts

@@ -0,0 +1,18 @@
+import {
+  GetPublicKeyArgs,
+  GetPublicKeyResult,
+  OriginatorDomainNameStringUnder250Bytes,
+  WalletDecryptArgs,
+  WalletDecryptResult,
+  WalletEncryptArgs,
+  WalletEncryptResult
+} from '@bsv/sdk'
+
+export interface CertOpsWallet {
+  getPublicKey(
+    args: GetPublicKeyArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<GetPublicKeyResult>
+  encrypt(args: WalletEncryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletEncryptResult>
+  decrypt(args: WalletDecryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletDecryptResult>
+}