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

package/src/monitor/tasks/TaskReviewStatus.ts

@@ -1,48 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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>
-}