@bsv/wallet-toolbox 1.3.23 → 1.3.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.3.23",
+  "version": "1.3.25",
   "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.1",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/Wallet.ts

@@ -721,24 +721,30 @@ export class Wallet implements WalletInterface, ProtoWallet {
     return r
   }
 
-  async abortAction(
-    args: AbortActionArgs,
+  async internalizeAction(
+    args: InternalizeActionArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<AbortActionResult> {
+  ): Promise<InternalizeActionResult> {
     sdk.validateOriginator(originator)
+    const { auth, vargs } = this.validateAuthAndArgs(args, sdk.validateInternalizeActionArgs)
+
+    if (vargs.labels.indexOf(specOpThrowReviewActions) >= 0) throwDummyReviewActions()
+
+    const r = await internalizeAction(this, auth, args)
+
+    throwIfUnsuccessfulInternalizeAction(r)
 
-    const { auth } = this.validateAuthAndArgs(args, sdk.validateAbortActionArgs)
-    const r = await this.storage.abortAction(args)
     return r
   }
 
-  async internalizeAction(
-    args: InternalizeActionArgs,
+  async abortAction(
+    args: AbortActionArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<InternalizeActionResult> {
+  ): Promise<AbortActionResult> {
     sdk.validateOriginator(originator)
-    const { auth, vargs } = this.validateAuthAndArgs(args, sdk.validateInternalizeActionArgs)
-    const r = await internalizeAction(this, auth, args)
+
+    const { auth } = this.validateAuthAndArgs(args, sdk.validateAbortActionArgs)
+    const r = await this.storage.abortAction(args)
     return r
   }
 
@@ -1000,6 +1006,15 @@ function throwIfAnyUnsuccessfulSignActions(r: SignActionResultX) {
   throw new sdk.WERR_REVIEW_ACTIONS(ndrs, swrs, r.txid, r.tx)
 }
 
+function throwIfUnsuccessfulInternalizeAction(r: sdk.StorageInternalizeActionResult) {
+  const ndrs = r.notDelayedResults
+  const swrs = r.sendWithResults
+
+  if (!ndrs || !swrs || swrs.every(r => r.status === 'unproven')) return
+
+  throw new sdk.WERR_REVIEW_ACTIONS(ndrs, swrs, r.txid)
+}
+
 /**
  * Throws a WERR_REVIEW_ACTIONS with a full set of properties to test data formats and propagation.
  */

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,13 +130,13 @@ 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))
     this._tasks.push(new TaskFailAbandoned(this, 8 * this.oneMinute))
     this._tasks.push(new TaskUnFail(this))
-    // No purging until invalid transactions are really invalid...
-    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
+    this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
     this._tasks.push(new TaskReviewStatus(this))
   }
 
@@ -145,13 +147,13 @@ 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))
     this._tasks.push(new TaskFailAbandoned(this, 8 * this.oneMinute))
     this._tasks.push(new TaskUnFail(this))
-    // No purging until invalid transactions are really invalid...
-    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
+    this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
     this._tasks.push(new TaskReviewStatus(this))
   }
 

package/src/monitor/tasks/TaskNewHeader.ts

@@ -1,4 +1,4 @@
-import { BlockHeader } from '../../services/chaintracker/chaintracks/BlockHeaderApi'
+import { BlockHeader } from '../../services/chaintracker/chaintracks/Api/BlockHeaderApi'
 import { Monitor } from '../Monitor'
 import { WalletMonitorTask } from './WalletMonitorTask'
 

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

@@ -200,6 +200,8 @@ export interface WalletServicesOptions {
   chaintracks?: ChaintracksServiceClient
   arcUrl: string
   arcConfig: ArcConfig
+  arcGorillaPoolUrl?: string
+  arcGorillaPoolConfig?: ArcConfig
 }
 
 export interface GetStatusForTxidsResult {

package/src/sdk/WalletStorage.interfaces.ts

@@ -155,7 +155,7 @@ export interface WalletStorageWriter extends WalletStorageReader {
   abortAction(auth: AuthId, args: AbortActionArgs): Promise<AbortActionResult>
   createAction(auth: AuthId, args: ValidCreateActionArgs): Promise<StorageCreateActionResult>
   processAction(auth: AuthId, args: StorageProcessActionArgs): Promise<StorageProcessActionResults>
-  internalizeAction(auth: AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult>
+  internalizeAction(auth: AuthId, args: InternalizeActionArgs): Promise<StorageInternalizeActionResult>
 
   insertCertificateAuth(auth: AuthId, certificate: TableCertificateX): Promise<number>
 
@@ -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 {
@@ -267,6 +272,20 @@ export interface StorageProcessActionArgs {
   log?: string
 }
 
+export interface StorageInternalizeActionResult extends InternalizeActionResult {
+  /** true if internalizing outputs on an existing storage transaction */
+  isMerge: boolean
+  /** txid of transaction being internalized */
+  txid: string
+  /** net change in change balance for user due to this internalization */
+  satoshis: number
+
+  /** valid iff not isMerge and txid was unknown to storage and non-delayed broadcast was not success */
+  sendWithResults?: SendWithResult[]
+  /** valid iff not isMerge and txid was unknown to storage and non-delayed broadcast was not success */
+  notDelayedResults?: ReviewActionResult[]
+}
+
 /**
  * Indicates status of a new Action following a `createAction` or `signAction` in immediate mode:
  * When `acceptDelayedBroadcast` is falses.
@@ -333,6 +352,7 @@ export interface PurgeResults {
 export interface StorageProvenOrReq {
   proven?: TableProvenTx
   req?: TableProvenTxReq
+  isNew?: boolean
 }
 
 /**

package/src/services/ServiceCollection.ts

@@ -1,10 +1,16 @@
+import { WalletError } from "../sdk/WalletError";
+
 export class ServiceCollection<T> {
+  since: Date
   services: { name: string; service: T }[]
   _index: number
 
+  _callHistory: Record<string, ServiceCallHistory> = {}
+
   constructor(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 +30,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(), durationMsecs: 0, success: false, result: undefined, error: undefined }
+    return { 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)
   }
@@ -47,4 +70,102 @@ export class ServiceCollection<T> {
   clone(): ServiceCollection<T> {
     return new ServiceCollection([...this.services])
   }
+
+  _addServiceCall(name: string, call: ServiceCall): ServiceCallHistory {
+    let h = this._callHistory[name]
+    if (!h) {
+      h = { name, calls: [], count: 0, countError: 0, countFailure: 0, countSuccess: 0, since: this.since }
+      this._callHistory[name] = h
+    }
+    h.calls.push(call)
+    h.count++
+    h.calls = h.calls.slice(-32)
+    return h
+  }
+
+  addServiceCallSuccess(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = true
+    call.result = result
+    call.error = undefined
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countSuccess++
+  }
+
+  addServiceCallFailure(stc: ServiceToCall<T>, result?: string): void {
+    const call = stc.call
+    call.success = false
+    call.result = result
+    call.error = undefined
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countFailure++
+  }
+
+  addServiceCallError(stc: ServiceToCall<T>, error: WalletError): void {
+    const call = stc.call
+    call.success = false
+    call.result = undefined
+    call.error = error
+    call.durationMsecs = new Date().getTime() - call.when.getTime()
+    this._addServiceCall(this.name, call).countError++
+  }
+
+  /**
+   * @returns A copy of current service call history
+   */
+  getServiceCallHistory(reset?: boolean): Record<string, ServiceCallHistory> {
+    const histories: Record<string, ServiceCallHistory> = {}
+    for (const name of Object.keys(this._callHistory)) {
+      const h = this._callHistory[name]
+      histories[name] = {
+        name: h.name,
+        count: h.count,
+        countError: h.countError,
+        countFailure: h.countFailure,
+        countSuccess: h.countSuccess,
+        since: h.since,
+        calls: h.calls.map(c => ({
+          name: c.name,
+          when: c.when,
+          durationMsecs: c.durationMsecs,
+          success: c.success,
+          result: c.result,
+          error: c.error ? { message: c.error.message, code: c.error.code } : undefined
+        }))
+      }
+      if (reset) {
+        h.count = 0
+        h.countError = 0
+        h.countFailure = 0
+        h.countSuccess = 0
+        h.since = new Date()
+      }
+    }
+    return histories
+  }
 }
+
+export interface ServiceCall {
+  name: string
+  when: Date
+  durationMsecs: number
+  success: boolean
+  result?: string
+  error?: { message: string, code: string }
+}
+
+export interface ServiceCallHistory {
+  name: string
+  calls: ServiceCall[]
+  count: number
+  countSuccess: number
+  countFailure: number
+  countError: number
+  since: Date
+}
+
+export interface ServiceToCall<T> {
+  name: string
+  service: T
+  call: ServiceCall
+}