@bsv/wallet-toolbox 1.3.24 → 1.3.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.3.24",
+  "version": "1.3.26",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -32,7 +32,7 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.1.2",
     "@bsv/payment-express-middleware": "^1.0.6",
-    "@bsv/sdk": "^1.4.24",
+    "@bsv/sdk": "^1.5.2",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/monitor/Monitor.ts

@@ -13,6 +13,7 @@ import { TaskFailAbandoned } from './tasks/TaskFailAbandoned'
 import { TaskCheckForProofs } from './tasks/TaskCheckForProofs'
 import { TaskClock } from './tasks/TaskClock'
 import { TaskNewHeader } from './tasks/TaskNewHeader'
+import { TaskServiceCallHistory } from './tasks/TaskServiceCallHistory'
 
 import { TaskSendWaiting } from './tasks/TaskSendWaiting'
 import { TaskCheckNoSends } from './tasks/TaskCheckNoSends'
@@ -110,6 +111,7 @@ export class Monitor {
   addAllTasksToOther(): void {
     this._otherTasks.push(new TaskClock(this))
     this._otherTasks.push(new TaskNewHeader(this))
+    this._otherTasks.push(new TaskServiceCallHistory(this))
     this._otherTasks.push(new TaskPurge(this, this.defaultPurgeParams))
     this._otherTasks.push(new TaskReviewStatus(this))
     this._otherTasks.push(new TaskSendWaiting(this))
@@ -128,6 +130,7 @@ export class Monitor {
   addDefaultTasks(): void {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
+    this._tasks.push(new TaskServiceCallHistory(this))
     this._tasks.push(new TaskSendWaiting(this, 8 * this.oneSecond, 7 * this.oneSecond)) // Check every 8 seconds but must be 7 seconds old
     this._tasks.push(new TaskCheckForProofs(this, 2 * this.oneHour)) // Every two hours if no block found
     this._tasks.push(new TaskCheckNoSends(this))
@@ -144,6 +147,7 @@ export class Monitor {
   addMultiUserTasks(): void {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
+    this._tasks.push(new TaskServiceCallHistory(this))
     this._tasks.push(new TaskSendWaiting(this, 8 * this.oneSecond, 7 * this.oneSecond)) // Check every 8 seconds but must be 7 seconds old
     this._tasks.push(new TaskCheckForProofs(this, 2 * this.oneHour)) // Every two hours if no block found
     this._tasks.push(new TaskCheckNoSends(this))

package/src/monitor/tasks/TaskServiceCallHistory.ts

@@ -0,0 +1,26 @@
+import { TableMonitorEvent } from '../../storage/index.client'
+import { Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+
+export class TaskServiceCallHistory extends WalletMonitorTask {
+  static taskName = 'ServiceCallHistory'
+
+  constructor(
+    monitor: Monitor,
+    public triggerMsecs = monitor.oneMinute * 12
+  ) {
+    super(monitor, TaskServiceCallHistory.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    return {
+      run: nowMsecsSinceEpoch > this.lastRunMsecsSinceEpoch + this.triggerMsecs
+    }
+  }
+
+  async runTask(): Promise<string> {
+    const r = await this.monitor.services.getServicesCallHistory(true)
+    const log = JSON.stringify(r)
+    return log
+  }
+}

package/src/sdk/WalletServices.interfaces.ts

@@ -168,6 +168,12 @@ export interface WalletServices {
    * @param txid
    */
   getBeefForTxid(txid: string): Promise<Beef>
+
+  /**
+   * @param reset if true, ends current interval and starts a new one.
+   * @returns a history of service calls made to the configured services.
+   */
+  getServicesCallHistory(reset?: boolean) : ServicesCallHistory
 }
 
 export type ScriptHashFormat = 'hashLE' | 'hashBE' | 'script'
@@ -200,6 +206,8 @@ export interface WalletServicesOptions {
   chaintracks?: ChaintracksServiceClient
   arcUrl: string
   arcConfig: ArcConfig
+  arcGorillaPoolUrl?: string
+  arcGorillaPoolConfig?: ArcConfig
 }
 
 export interface GetStatusForTxidsResult {
@@ -495,3 +503,100 @@ export type UpdateFiatExchangeRateService = (
   targetCurrencies: string[],
   options: WalletServicesOptions
 ) => Promise<FiatExchangeRates>
+
+/**
+ * Type for the service call history returned by Services.getServicesCallHistory.
+ */
+export type ServicesCallHistory = {
+  version: number
+  getMerklePath: ServiceCallHistory
+  getRawTx: ServiceCallHistory
+  postBeef: ServiceCallHistory
+  getUtxoStatus: ServiceCallHistory
+  getStatusForTxids: ServiceCallHistory
+  getScriptHashHistory: ServiceCallHistory
+  updateFiatExchangeRates: ServiceCallHistory
+}
+
+/**
+ * Minimum data tracked for each service call.
+ */
+export interface ServiceCall {
+  /**
+   * string value must be Date's toISOString format.
+   */
+  when: Date | string
+  msecs: number
+  /**
+   * true iff service provider successfully processed the request
+   * false iff service provider failed to process the request which includes thrown errors.
+   */
+  success: boolean
+  /**
+   * Simple text summary of result. e.g. `not a valid utxo` or `valid utxo`
+   */
+  result?: string
+  /**
+   * Error code and message iff success is false and a exception was thrown.
+   */
+  error?: { message: string, code: string }
+}
+
+/**
+ * Counts of service calls over a time interval.
+ */
+export interface ServiceCallHistoryCounts {
+  /**
+   * count of calls returning success true.
+   */
+  success: number
+  /**
+   * count of calls returning success false.
+   */
+  failure: number
+  /**
+   * of failures (success false), count of calls with valid error code and message.
+   */
+  error: number
+  /**
+   * Counts are of calls over interval `since` to `until`.
+   * string value must be Date's toISOString format.
+   */
+  since: Date | string
+  /**
+   * Counts are of calls over interval `since` to `until`.
+   * string value must be Date's toISOString format.
+   */
+  until: Date | string
+}
+
+/**
+ * History of service calls for a single service, single provider.
+ */
+export interface ProviderCallHistory {
+  providerName: string
+  serviceName: string
+  /**
+   * Most recent service calls.
+   * Array length is limited by Services configuration.
+   */
+  calls: ServiceCall[]
+  /**
+   * Counts since creation of Services instance.
+   */
+  totalCounts: ServiceCallHistoryCounts
+  /**
+   * Entry [0] is always the current interval being extended by new calls.
+   * when `getServiceCallHistory` with `reset` true is called, a new interval with zero counts is added to the start of array.
+   * Array length is limited by Services configuration.
+   */
+  resetCounts: ServiceCallHistoryCounts[]
+}
+
+/**
+ * History of service calls for a single service, all providers.
+ */
+export interface ServiceCallHistory {
+  serviceName: string
+  historyByProvider: Record<string, ProviderCallHistory>
+}

package/src/sdk/WalletStorage.interfaces.ts

@@ -189,6 +189,11 @@ export interface FindSincePagedArgs {
   since?: Date
   paged?: Paged
   trx?: TrxToken
+  /**
+   * Support for orderDescending is implemented in StorageKnex for basic table find methods,
+   * excluding certificate_fields table, map tables, and settings (singleton row table).
+   */
+  orderDescending?: boolean
 }
 
 export interface FindForUserSincePagedArgs extends FindSincePagedArgs {

package/src/services/ServiceCollection.ts

@@ -1,10 +1,23 @@
+import { WalletError } from "../sdk/WalletError";
+import { ProviderCallHistory, ServiceCallHistory } from "../sdk/WalletServices.interfaces";
+
+const MAX_RESET_COUNTS = 32
+const MAX_CALL_HISTORY = 32
+
 export class ServiceCollection<T> {
   services: { name: string; service: T }[]
   _index: number
 
-  constructor(services?: { name: string; service: T }[]) {
+  /**
+   * Start of currentCounts interval. Initially instance construction time.
+   */
+  readonly since: Date
+  _historyByProvider: Record<string, ProviderCallHistory> = {}
+
+  constructor(public serviceName: string, services?: { name: string; service: T }[]) {
     this.services = services || []
     this._index = 0
+    this.since = new Date()
   }
 
   add(s: { name: string; service: T }): ServiceCollection<T> {
@@ -24,6 +37,23 @@ export class ServiceCollection<T> {
     return this.services[this._index].service
   }
 
+  get serviceToCall(): ServiceToCall<T> {
+    const i = this._index
+    const name = this.services[i].name
+    const service = this.services[i].service
+    const call = { name, when: new Date(), msecs: 0, success: false, result: undefined, error: undefined }
+    return { serviceName: this.serviceName, providerName: name, service, call }
+  }
+
+  get allServicesToCall(): ServiceToCall<T>[] {
+    const all: ServiceToCall<T>[] = []
+    for (let i = 0; i < this.services.length; i++) {
+      all.push(this.serviceToCall)
+      this.next()
+    }
+    return all
+  }
+
   get allServices() {
     return this.services.map(x => x.service)
   }
@@ -45,6 +75,157 @@ export class ServiceCollection<T> {
   }
 
   clone(): ServiceCollection<T> {
-    return new ServiceCollection([...this.services])
+    return new ServiceCollection(this.serviceName, [...this.services])
+  }
+
+  _addServiceCall(providerName: string, call: ServiceCall): ProviderCallHistory {
+    const now = new Date()
+    let h = this._historyByProvider[providerName]
+    if (!h) {
+      h = {
+        serviceName: this.serviceName,
+        providerName: providerName,
+        calls: [],
+        totalCounts: { success: 0, failure: 0, error: 0, since: this.since, until: now },
+        resetCounts: [{ success: 0, failure: 0, error: 0, since: this.since, until: now }]
+      }
+      this._historyByProvider[providerName] = h
+    }
+    h.calls.unshift(call)
+    h.calls = h.calls.slice(0,MAX_CALL_HISTORY)
+    h.totalCounts.until = now
+    h.resetCounts[0].until = now
+    return h
+  }
+
+  getDuration(since: Date | string): number {
+    const now = new Date()
+    if (typeof since === 'string') since = new Date(since)
+    return now.getTime() - since.getTime()
+  }
+
+  addServiceCallSuccess(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = true
+    call.result = result
+    call.error = undefined
+    call.msecs = this.getDuration(call.when)
+    const h = this._addServiceCall(stc.providerName, call)
+    h.totalCounts.success++
+    h.resetCounts[0].success++
+  }
+
+  addServiceCallFailure(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = false
+    call.result = result
+    call.error = undefined
+    call.msecs = this.getDuration(call.when)
+    const h = this._addServiceCall(this.name, call)
+    h.totalCounts.failure++
+    h.resetCounts[0].failure++
+  }
+
+  addServiceCallError(stc: ServiceToCall<T>, error: WalletError): void {
+    const call = stc.call
+    call.success = false
+    call.result = undefined
+    call.error = error
+    call.msecs = this.getDuration(call.when)
+    const h = this._addServiceCall(this.name, call)
+    h.totalCounts.failure++
+    h.totalCounts.error++
+    h.resetCounts[0].failure++
+    h.resetCounts[0].error++
+  }
+
+  /**
+   * @returns A copy of current service call history
+   */
+  getServiceCallHistory(reset?: boolean): ServiceCallHistory {
+    const now = new Date()
+    const history: ServiceCallHistory = { serviceName: this.serviceName, historyByProvider: {} }
+    for (const name of Object.keys(this._historyByProvider)) {
+      const h = this._historyByProvider[name]
+      const c: ProviderCallHistory = {
+        serviceName: h.serviceName,
+        providerName: h.providerName,
+        calls: h.calls.map(c => ({
+          when: dateToString(c.when),
+          msecs: c.msecs,
+          success: c.success,
+          result: c.result,
+          error: c.error ? { message: c.error.message, code: c.error.code } : undefined
+        })),
+        totalCounts: {
+          success: h.totalCounts.success,
+          failure: h.totalCounts.failure,
+          error: h.totalCounts.error,
+          since: dateToString(h.totalCounts.since),
+          until: dateToString(h.totalCounts.until)
+        },
+        resetCounts: []
+      }
+      for (let i = 0; i < h.resetCounts.length; i++) {
+        const r = h.resetCounts[i]
+        c.resetCounts.push({
+          success: r.success,
+          failure: r.failure,
+          error: r.error,
+          since: dateToString(r.since),
+          until: dateToString(r.until)
+        })
+      }
+      history.historyByProvider[name] = c
+      if (reset) {
+        // Make sure intervals are continuous.
+        h.resetCounts[0].until = now
+        // insert a new resetCounts interval
+        h.resetCounts.unshift({
+          success: 0,
+          failure: 0,
+          error: 0,
+          // start of new interval
+          since: now,
+          // end of new interval, gets bumped with each new call added
+          until: now
+        })
+        // limit history to most recent intervals
+        h.resetCounts = h.resetCounts.slice(0, MAX_CALL_HISTORY)
+      }
+    }
+    return history
+
+    function dateToString(d: Date | string): string {
+      return typeof d === 'string' ? d : d.toISOString()
+    }
   }
 }
+
+export interface ServiceCall {
+  /**
+   * string value must be Date's toISOString format.
+   */
+  when: Date | string
+  msecs: number
+  /**
+   * true iff service provider successfully processed the request
+   * false iff service provider failed to process the request which includes thrown errors.
+   */
+  success: boolean
+  /**
+   * Simple text summary of result. e.g. `not a valid utxo` or `valid utxo`
+   */
+  result?: string
+  /**
+   * Error code and message iff success is false and a exception was thrown.
+   */
+  error?: { message: string, code: string }
+}
+
+export interface ServiceToCall<T> {
+  providerName: string
+  serviceName: string
+  service: T
+  call: ServiceCall
+}