@bsv/wallet-toolbox 1.5.12 → 1.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.5.12",
+  "version": "1.5.13",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/monitor/Monitor.ts

@@ -42,6 +42,12 @@ export interface MonitorOptions {
   unprovenAttemptsLimitTest: number
 
   unprovenAttemptsLimitMain: number
+
+  /**
+   * These are hooks for a wallet-toolbox client to get transaction updates.
+   */
+  onTransactionBroadcasted?: (broadcastResult: sdk.ReviewActionResult) => Promise<void>
+  onTransactionProven?: (txStatus: sdk.ProvenTransactionStatus) => Promise<void>
 }
 
 /**
@@ -75,6 +81,8 @@ export class Monitor {
   chain: sdk.Chain
   storage: MonitorStorage
   chaintracks: ChaintracksServiceClient
+  onTransactionBroadcasted?: (broadcastResult: sdk.ReviewActionResult) => Promise<void>
+  onTransactionProven?: (txStatus: sdk.ProvenTransactionStatus) => Promise<void>
 
   constructor(options: MonitorOptions) {
     this.options = { ...options }
@@ -82,6 +90,8 @@ export class Monitor {
     this.chain = this.services.chain
     this.storage = options.storage
     this.chaintracks = options.chaintracks
+    this.onTransactionProven = options.onTransactionProven
+    this.onTransactionBroadcasted = options.onTransactionBroadcasted
   }
 
   oneSecond = 1000
@@ -286,6 +296,32 @@ export class Monitor {
     TaskCheckForProofs.checkNow = true
   }
 
+  /**
+   * This is a function run from a TaskSendWaiting Monitor task.
+   *
+   * This allows the user of wallet-toolbox to 'subscribe' for transaction broadcast updates.
+   *
+   * @param broadcastResult
+   */
+  callOnBroadcastedTransaction(broadcastResult: sdk.ReviewActionResult): void {
+    if (this.onTransactionBroadcasted) {
+      this.onTransactionBroadcasted(broadcastResult)
+    }
+  }
+
+  /**
+   * This is a function run from a TaskCheckForProofs Monitor task.
+   *
+   * This allows the user of wallet-toolbox to 'subscribe' for transaction updates.
+   *
+   * @param txStatus
+   */
+  callOnProvenTransaction(txStatus: sdk.ProvenTransactionStatus): void {
+    if (this.onTransactionProven) {
+      this.onTransactionProven(txStatus)
+    }
+  }
+
   /**
    * Process reorg event received from Chaintracks
    *
@@ -301,18 +337,3 @@ export class Monitor {
     /* */
   }
 }
-
-function sum<T>(a: T[], getNum: (v: T) => number): number {
-  let s = 0
-  for (const v of a) s += getNum(v)
-  return s
-}
-
-function filter<T>(a: T[], pred: (v: T) => boolean): { ts: T[]; fs: T[] } {
-  const ts: T[] = []
-  const fs: T[] = []
-  for (const v of a)
-    if (pred(v)) ts.push(v)
-    else fs.push(v)
-  return { ts, fs }
-}

package/src/monitor/tasks/TaskCheckForProofs.ts

@@ -216,6 +216,15 @@ export async function getProofs(
       req.apiHistory = r.history
       req.provenTxId = r.provenTxId
       req.notified = true
+
+      task.monitor.callOnProvenTransaction({
+        txid,
+        txIndex: index,
+        blockHeight: height,
+        blockHash,
+        merklePath,
+        merkleRoot
+      })
     } else {
       if (countsAsAttempt && req.status !== 'nosend') {
         req.attempts++

package/src/monitor/tasks/TaskSendWaiting.ts

@@ -3,7 +3,9 @@ import { verifyTruthy } from '../../utility/index.client'
 import { Monitor } from '../Monitor'
 import { WalletMonitorTask } from './WalletMonitorTask'
 import { attemptToPostReqsToNetwork } from '../../storage/methods/attemptToPostReqsToNetwork'
-import { ProvenTxReqStatus } from '../../sdk'
+import { ProvenTxReqStatus, WERR_INTERNAL } from '../../sdk'
+import { ReviewActionResult, SendWithResult } from '@bsv/sdk'
+import { aggregateActionResults } from '../../utility/aggregateResults'
 
 export class TaskSendWaiting extends WalletMonitorTask {
   static taskName = 'SendWaiting'
@@ -103,6 +105,15 @@ export class TaskSendWaiting extends WalletMonitorTask {
         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/sdk/types.ts

@@ -133,6 +133,18 @@ export type ReqHistoryNote = {
   [key: string]: boolean | string | number | undefined
 }
 
+/**
+ * The transaction status that a client will receive when subscribing to transaction updates in the Monitor.
+ */
+export interface ProvenTransactionStatus {
+  txid: string
+  txIndex: number
+  blockHeight: number
+  blockHash: string
+  merklePath: number[]
+  merkleRoot: string
+}
+
 /**
  * `listOutputs` special operation basket name value.
  *

package/src/services/__tests/ARC.timeout.man.test.ts

@@ -45,7 +45,7 @@ describe('ARC tests', () => {
 
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
-      'XDeployment-ID': 'wallet-toolbox-test11',
+      'XDeployment-ID': 'wallet-toolbox-test11'
       //Authorization: `Bearer ${envMain.gorillaPoolApiKey}`
     }
 

package/src/storage/methods/processAction.ts

@@ -7,9 +7,7 @@ import {
   parseTxScriptOffsets,
   randomBytesBase64,
   sdk,
-  sha256Hash,
   stampLog,
-  stampLogFormat,
   StorageProvider,
   TableCommission,
   TableOutput,
@@ -17,16 +15,14 @@ import {
   TableProvenTxReq,
   TableTransaction,
   TxScriptOffsets,
-  validateStorageFeeModel,
   verifyId,
   verifyInteger,
-  verifyNumber,
   verifyOne,
   verifyOneOrNone,
   verifyTruthy
 } from '../../index.client'
-import { ReviewActionResult, ProvenTxReqNonTerminalStatus, StorageGetBeefOptions } from '../../sdk'
-import { PostReqsToNetworkDetails } from './attemptToPostReqsToNetwork'
+import { ReviewActionResult } from '../../sdk'
+import { aggregateActionResults } from '../../utility/aggregateResults'
 
 export async function processAction(
   storage: StorageProvider,
@@ -122,15 +118,6 @@ export async function shareReqsWithWorld(
   // Collect what we know about these sendWith transaction txids from storage.
   const r = await storage.getReqsAndBeefToShareWithWorld(txids, [])
 
-  // Initialize aggregate results for each txid
-  const ars: {
-    txid: string
-    status: SendWithResultStatus
-    getReq: GetReqsAndBeefDetail
-    postReq?: PostReqsToNetworkDetails
-    ndr?: ReviewActionResult
-  }[] = []
-
   const readyToSendReqs: EntityProvenTxReq[] = []
   for (const getReq of r.details) {
     let status: SendWithResultStatus = 'failed'
@@ -139,9 +126,8 @@ export async function shareReqsWithWorld(
       status = 'sending'
       readyToSendReqs.push(new EntityProvenTxReq(getReq.req!))
     }
-    ars.push({
+    swr.push({
       txid: getReq.txid,
-      getReq,
       status
     })
   }
@@ -171,11 +157,11 @@ export async function shareReqsWithWorld(
         await storage.updateTransaction(transactionIds, { status: 'sending' }, trx)
       })
     }
-    return createResults()
+    return { swr, ndr }
   }
 
   if (readyToSendReqIds.length < 1) {
-    return createResults()
+    return { swr, ndr }
   }
 
   if (batch) {
@@ -189,53 +175,8 @@ export async function shareReqsWithWorld(
   //
   const prtn = await storage.attemptToPostReqsToNetwork(readyToSendReqs)
 
-  // merge the individual PostBeefResultForTxid results to postBeef in aggregate results.
-  for (const ar of ars) {
-    const txid = ar.txid
-    const d = prtn.details.find(d => d.txid === txid)
-    if (!d) throw new sdk.WERR_INTERNAL(`missing details for ${txid}`)
-    ar.ndr = { txid: d.txid, status: 'success', competingTxs: d.competingTxs }
-    switch (d.status) {
-      case 'success':
-        // processing network has accepted this transaction
-        ar.status = 'unproven'
-        break
-      case 'doubleSpend':
-        // confirmed double spend.
-        ar.status = 'failed'
-        ar.ndr.status = 'doubleSpend'
-        if (d.competingTxs) ar.ndr.competingBeef = await createMergedBeefOfTxids(d.competingTxs, storage)
-        break
-      case 'serviceError':
-        // services might improve
-        ar.status = 'sending'
-        ar.ndr.status = 'serviceError'
-        break
-      case 'invalidTx':
-        // nothing will fix this transaction
-        ar.status = 'failed'
-        ar.ndr.status = 'invalidTx'
-        break
-      case 'unknown':
-      case 'invalid':
-      default:
-        throw new sdk.WERR_INTERNAL(`processAction with notDelayed status ${d.status} should not occur.`)
-    }
-  }
-
-  return createResults()
-
-  function createResults(): { swr: SendWithResult[]; ndr: ReviewActionResult[] | undefined } {
-    swr = []
-    ndr = isDelayed ? undefined : []
-    for (const ar of ars) {
-      swr.push({ txid: ar.txid, status: ar.status })
-      if (ar.ndr && ndr) {
-        ndr.push(ar.ndr)
-      }
-    }
-    return { swr, ndr }
-  }
+  const { swr: swrRes, rar } = await aggregateActionResults(storage, swr, prtn)
+  return { swr: swrRes, ndr: rar }
 }
 
 interface ReqTxStatus {
@@ -452,15 +393,3 @@ async function commitNewTxToStorage(
 
   return r
 }
-
-async function createMergedBeefOfTxids(txids: string[], storage: StorageProvider): Promise<number[]> {
-  const beef = new Beef()
-  const options: StorageGetBeefOptions = {
-    mergeToBeef: beef,
-    ignoreNewProven: true
-  }
-  for (const txid of txids) {
-    await storage.getBeefForTransaction(txid, options)
-  }
-  return beef.toBinary()
-}

package/src/utility/aggregateResults.ts

@@ -0,0 +1,68 @@
+import { Beef, ReviewActionResult, SendWithResult } from '@bsv/sdk'
+import { PostReqsToNetworkResult } from '../storage/methods/attemptToPostReqsToNetwork'
+import { StorageGetBeefOptions, WERR_INTERNAL } from '../sdk'
+import { StorageProvider } from '../index.client'
+
+export const aggregateActionResults = async (
+  storage: StorageProvider,
+  sendWithResultReqs: SendWithResult[],
+  postToNetworkResult: PostReqsToNetworkResult
+): Promise<{
+  swr: SendWithResult[]
+  rar: ReviewActionResult[]
+}> => {
+  const swr: SendWithResult[] = []
+  const rar: ReviewActionResult[] = []
+
+  for (const ar of sendWithResultReqs) {
+    const txid = ar.txid
+
+    const d = postToNetworkResult.details.find(d => d.txid === txid)
+    if (!d) throw new WERR_INTERNAL(`missing details for ${txid}`)
+
+    const arNdr: ReviewActionResult = { txid: d.txid, status: 'success', competingTxs: d.competingTxs }
+    switch (d.status) {
+      case 'success':
+        // processing network has accepted this transaction
+        ar.status = 'unproven'
+        break
+      case 'doubleSpend':
+        // confirmed double spend.
+        ar.status = 'failed'
+        arNdr.status = 'doubleSpend'
+        if (d.competingTxs) arNdr.competingBeef = await createMergedBeefOfTxids(d.competingTxs, storage)
+        break
+      case 'serviceError':
+        // services might improve
+        ar.status = 'sending'
+        arNdr.status = 'serviceError'
+        break
+      case 'invalidTx':
+        // nothing will fix this transaction
+        ar.status = 'failed'
+        arNdr.status = 'invalidTx'
+        break
+      case 'unknown':
+      case 'invalid':
+      default:
+        throw new WERR_INTERNAL(`processAction with notDelayed status ${d.status} should not occur.`)
+    }
+
+    swr.push({ txid, status: ar.status })
+    rar.push(arNdr)
+  }
+
+  return { swr, rar }
+}
+
+async function createMergedBeefOfTxids(txids: string[], storage: StorageProvider): Promise<number[]> {
+  const beef = new Beef()
+  const options: StorageGetBeefOptions = {
+    mergeToBeef: beef,
+    ignoreNewProven: true
+  }
+  for (const txid of txids) {
+    await storage.getBeefForTransaction(txid, options)
+  }
+  return beef.toBinary()
+}

package/test/monitor/Monitor.test.ts

@@ -1,4 +1,4 @@
-import { MerklePath } from '@bsv/sdk'
+import { Beef, MerklePath } from '@bsv/sdk'
 import { asArray, EntityProvenTxReq, sdk, verifyOne, verifyTruthy, wait } from '../../src/index.client'
 import { TaskCheckForProofs } from '../../src/monitor/tasks/TaskCheckForProofs'
 import { TaskClock } from '../../src/monitor/tasks/TaskClock'
@@ -490,4 +490,126 @@ describe('Monitor tests', () => {
       await ctx.storage.destroy()
     }
   })
+
+  test('8 ProcessProvenTransaction', async () => {
+    const ctxs: TestWallet<{}>[] = []
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('monitorTest8'))
+    let mockResultIndex = 0
+    let updatesReceived = 0
+
+    const expectedTxids = [
+      'c099c52277426abb863dc902d0389b008ddf2301d6b40ac718746ac16ca59136',
+      '6935ce33b9e3b9ee60360ce0606aa0a0970b4840203f457b5559212676dc33ab',
+      '67ca2475886b3fc2edd76a2eb8c32bd0bc308176c7dff463e0507942aeebcbec',
+      '3fa94b62a3b10d8c18bada527a9b68c4e70db67140719df16c44fb0328782532',
+      '519675259eff036c6597e4a497d37c132e718171dde4ea2257e84c947ecf656b'
+    ]
+
+    _tu.mockMerklePathServicesAsCallback(ctxs, async txid => {
+      expect(expectedTxids).toContain(txid)
+      const r = mockGetMerklePathResults[mockResultIndex++]
+      return r
+    })
+
+    for (const { activeStorage: storage, monitor } of ctxs) {
+      if (!monitor) throw new sdk.WERR_INTERNAL('test requires setup with monitor')
+
+      monitor.lastNewHeader = {
+        height: 999999999,
+        hash: '',
+        time: 0,
+        version: 0,
+        previousHash: '',
+        merkleRoot: '',
+        bits: 0,
+        nonce: 0
+      }
+
+      monitor.onTransactionProven = async (txStatus: sdk.ProvenTransactionStatus) => {
+        expect(txStatus.txid).toBeTruthy()
+        expect(txStatus.blockHash).toBeTruthy()
+        expect(txStatus.blockHeight).toBeTruthy()
+        expect(txStatus.merkleRoot).toBeTruthy()
+        updatesReceived++
+      }
+
+      for (const txid of expectedTxids) {
+        // no matching ProvenTx exists.
+        expect((await storage.findProvenTxs({ partial: { txid } })).length).toBe(0)
+        const req = verifyTruthy(await EntityProvenTxReq.fromStorageTxid(storage, txid))
+        expect(req.status).toBe('unmined')
+      }
+
+      const task = new TaskCheckForProofs(monitor, 1)
+      monitor._tasks.push(task)
+
+      await monitor.runTask('CheckForProofs')
+
+      for (const txid of expectedTxids) {
+        const proven = verifyOne(await storage.findProvenTxs({ partial: { txid } }))
+        expect(proven.merklePath).toBeTruthy()
+        const req = verifyTruthy(await EntityProvenTxReq.fromStorageTxid(storage, txid))
+        expect(req.status).toBe('completed')
+        expect(req.provenTxId).toBe(proven.provenTxId)
+      }
+
+      expect(updatesReceived).toEqual(expectedTxids.length)
+    }
+
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('9 ProcessBroadcastedTransactions', async () => {
+    const ctxs: TestWallet<{}>[] = []
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('monitorTest8'))
+    let updatesReceived = 0
+    let txidsPosted: string[] = []
+
+    const expectedTxids = [
+      'd9ec73b2e0f06e0f482d2d1db9ceccf2f212f0b24afbe10846ac907567be571f',
+      'b7634f08d8c7f3c6244050bebf73a79f40e672aba7d5232663609a58b123b816',
+      '3d2ea64ee584a1f6eb161dbedf3a8d299e3e4497ac7a203d23c044c998c6aa08',
+      'a3a8fe7f541c1383ff7b975af49b27284ae720af5f2705d8409baaf519190d26',
+      '6d68cc6fa7363e59aaccbaa65f0ca613a6ae8af718453ab5d3a2b022c59b5cc6'
+    ]
+
+    _tu.mockPostServicesAsCallback(ctxs, (beef: Beef, txids: string[]) => {
+      txidsPosted.push(...txids)
+      return 'success'
+    })
+
+    for (const { activeStorage: storage, monitor } of ctxs) {
+      if (!monitor) throw new sdk.WERR_INTERNAL('test requires setup with monitor')
+
+      for (const txid of expectedTxids) {
+        const req = verifyTruthy(await EntityProvenTxReq.fromStorageTxid(storage, txid))
+        expect(req.status).toBe('unsent')
+      }
+
+      monitor.onTransactionBroadcasted = async (broadcastResult: sdk.ReviewActionResult) => {
+        expect(broadcastResult.status).toBe('success')
+        expect(expectedTxids).toContain(broadcastResult.txid)
+        updatesReceived++
+      }
+
+      const task = new TaskSendWaiting(monitor, 1, 1)
+      monitor._tasks.push(task)
+
+      await monitor.runTask('SendWaiting')
+
+      expect(txidsPosted).toEqual(expectedTxids)
+      for (const txid of expectedTxids) {
+        const req = verifyOne(await storage.findProvenTxReqs({ partial: { txid } }))
+        expect(req.status).toBe('unmined')
+      }
+
+      expect(updatesReceived).toEqual(expectedTxids.length)
+    }
+
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
 })