@bsv/wallet-toolbox 1.6.22 → 1.6.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.6.22",
+  "version": "1.6.24",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -22,8 +22,9 @@
     "test:coverage": "npm run build && jest --testPathIgnorePatterns=man.test.ts --coverage",
     "lint": "prettier --write 'src/**/*.ts' --write 'test/**/*.ts' --log-level silent",
     "build": "tsc --build",
-    "prepublish": "npm run lint && npm run build && npm run doc",
-    "doc": "ts2md"
+    "prepublish": "npm run lint && npm run build && npm run doc && npm run sync-versions",
+    "doc": "ts2md",
+    "sync-versions": "node syncVersions.js"
   },
   "bugs": {
     "url": "https://github.com/bsv-blockchain/wallet-toolbox/issues"
@@ -32,7 +33,7 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.2.3",
     "@bsv/payment-express-middleware": "^1.2.3",
-    "@bsv/sdk": "^1.7.3",
+    "@bsv/sdk": "^1.7.6",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/CWIStyleWalletManager.ts

@@ -61,7 +61,9 @@ import {
   Transaction,
   PushDrop,
   CreateActionInput,
-  SHIPBroadcaster
+  SHIPBroadcaster,
+  BigNumber,
+  Curve
 } from '@bsv/sdk'
 import { PrivilegedKeyManager } from './sdk/PrivilegedKeyManager'
 
@@ -1065,7 +1067,13 @@ export class CWIStyleWalletManager implements WalletInterface {
    * Lists all available profiles, including the default profile.
    * @returns Array of profile info objects, including an 'active' flag.
    */
-  listProfiles(): Array<{ id: number[]; name: string; createdAt: number | null; active: boolean }> {
+  listProfiles(): Array<{
+    id: number[]
+    name: string
+    createdAt: number | null
+    active: boolean
+    identityKey: string
+  }> {
     if (!this.authenticated) {
       throw new Error('Not authenticated.')
     }
@@ -1075,14 +1083,16 @@ export class CWIStyleWalletManager implements WalletInterface {
         id: DEFAULT_PROFILE_ID,
         name: 'default',
         createdAt: null, // Default profile doesn't have a creation timestamp in the same way
-        active: this.activeProfileId.every(x => x === 0)
+        active: this.activeProfileId.every(x => x === 0),
+        identityKey: new PrivateKey(this.rootPrimaryKey).toPublicKey().toString()
       },
       // Other profiles
       ...this.profiles.map(p => ({
         id: p.id,
         name: p.name,
         createdAt: p.createdAt,
-        active: this.activeProfileId.every((x, i) => x === p.id[i])
+        active: this.activeProfileId.every((x, i) => x === p.id[i]),
+        identityKey: new PrivateKey(this.XOR(this.rootPrimaryKey as number[], p.primaryPad)).toPublicKey().toString()
       }))
     ]
     return profileList

package/src/index.mobile.ts

@@ -2,7 +2,7 @@ export * as sdk from './sdk/index'
 
 export * from './utility/index.client'
 export * from './storage/index.mobile'
-export * from './services/chaintracker/chaintracks/index.client'
+export * from './services/chaintracker/chaintracks/index.mobile'
 
 export * from './CWIStyleWalletManager'
 export * from './monitor/Monitor'

package/src/monitor/Monitor.ts

@@ -11,6 +11,7 @@ import { TaskCheckForProofs } from './tasks/TaskCheckForProofs'
 import { TaskClock } from './tasks/TaskClock'
 import { TaskNewHeader } from './tasks/TaskNewHeader'
 import { TaskMonitorCallHistory } from './tasks/TaskMonitorCallHistory'
+import { TaskReorg } from './tasks/TaskReorg'
 
 import { TaskSendWaiting } from './tasks/TaskSendWaiting'
 import { TaskCheckNoSends } from './tasks/TaskCheckNoSends'
@@ -21,7 +22,8 @@ import { WERR_BAD_REQUEST, WERR_INVALID_PARAMETER } from '../sdk/WERR_errors'
 import { WalletError } from '../sdk/WalletError'
 import { BlockHeader } from '../sdk/WalletServices.interfaces'
 import { Services } from '../services/Services'
-import { ChaintracksClientApi } from '../services/chaintracker/chaintracks/Api/ChaintracksClientApi'
+import { ChaintracksClientApi, ReorgListener } from '../services/chaintracker/chaintracks/Api/ChaintracksClientApi'
+import { Chaintracks } from '../services/chaintracker/chaintracks/Chaintracks'
 
 export type MonitorStorage = WalletStorageManager
 
@@ -34,6 +36,8 @@ export interface MonitorOptions {
 
   chaintracks: ChaintracksClientApi
 
+  chaintracksWithEvents?: Chaintracks
+
   /**
    * How many msecs to wait after each getMerkleProof service request.
    */
@@ -59,7 +63,12 @@ export interface MonitorOptions {
  * and potentially that reorgs update proofs that were already received.
  */
 export class Monitor {
-  static createDefaultWalletMonitorOptions(chain: Chain, storage: MonitorStorage, services?: Services): MonitorOptions {
+  static createDefaultWalletMonitorOptions(
+    chain: Chain,
+    storage: MonitorStorage,
+    services?: Services,
+    chaintracks?: Chaintracks
+  ): MonitorOptions {
     services ||= new Services(chain)
     if (!services.options.chaintracks) throw new WERR_INVALID_PARAMETER('services.options.chaintracks', 'valid')
     const o: MonitorOptions = {
@@ -71,7 +80,8 @@ export class Monitor {
       abandonedMsecs: 1000 * 60 * 5,
       unprovenAttemptsLimitTest: 10,
       unprovenAttemptsLimitMain: 144,
-      chaintracks: services.options.chaintracks
+      chaintracks: services.options.chaintracks,
+      chaintracksWithEvents: chaintracks
     }
     return o
   }
@@ -81,6 +91,9 @@ export class Monitor {
   chain: Chain
   storage: MonitorStorage
   chaintracks: ChaintracksClientApi
+  chaintracksWithEvents?: Chaintracks
+  reorgSubscriptionPromise?: Promise<string>
+  headersSubscriptionPromise?: Promise<string>
   onTransactionBroadcasted?: (broadcastResult: ReviewActionResult) => Promise<void>
   onTransactionProven?: (txStatus: ProvenTransactionStatus) => Promise<void>
 
@@ -90,15 +103,31 @@ export class Monitor {
     this.chain = this.services.chain
     this.storage = options.storage
     this.chaintracks = options.chaintracks
+    this.chaintracksWithEvents = options.chaintracksWithEvents
     this.onTransactionProven = options.onTransactionProven
     this.onTransactionBroadcasted = options.onTransactionBroadcasted
+
+    if (this.chaintracksWithEvents) {
+      const c = this.chaintracksWithEvents
+      this.reorgSubscriptionPromise = c.subscribeReorgs(this.processReorg.bind(this))
+      this.headersSubscriptionPromise = c.subscribeHeaders(this.processHeader.bind(this))
+    }
   }
 
-  oneSecond = 1000
-  oneMinute = 60 * this.oneSecond
-  oneHour = 60 * this.oneMinute
-  oneDay = 24 * this.oneHour
-  oneWeek = 7 * this.oneDay
+  async destroy(): Promise<void> {
+    if (this.chaintracksWithEvents) {
+      const c = this.chaintracksWithEvents
+      if (this.reorgSubscriptionPromise) await c.unsubscribe(await this.reorgSubscriptionPromise)
+      if (this.headersSubscriptionPromise) await c.unsubscribe(await this.headersSubscriptionPromise)
+    }
+  }
+
+  static readonly oneSecond = 1000
+  static readonly oneMinute = 60 * Monitor.oneSecond
+  static readonly oneHour = 60 * Monitor.oneMinute
+  static readonly oneDay = 24 * Monitor.oneHour
+  static readonly oneWeek = 7 * Monitor.oneDay
+
   /**
    * _tasks are typically run by the scheduler but may also be run by runTask.
    */
@@ -113,9 +142,9 @@ export class Monitor {
     purgeSpent: false,
     purgeCompleted: false,
     purgeFailed: true,
-    purgeSpentAge: 2 * this.oneWeek,
-    purgeCompletedAge: 2 * this.oneWeek,
-    purgeFailedAge: 5 * this.oneDay
+    purgeSpentAge: 2 * Monitor.oneWeek,
+    purgeCompletedAge: 2 * Monitor.oneWeek,
+    purgeFailedAge: 5 * Monitor.oneDay
   }
 
   addAllTasksToOther(): void {
@@ -129,6 +158,8 @@ export class Monitor {
     this._otherTasks.push(new TaskCheckNoSends(this))
     this._otherTasks.push(new TaskUnFail(this))
 
+    this._otherTasks.push(new TaskReorg(this))
+
     this._otherTasks.push(new TaskFailAbandoned(this))
 
     this._otherTasks.push(new TaskSyncWhenIdle(this))
@@ -141,13 +172,14 @@ export class Monitor {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
     this._tasks.push(new TaskMonitorCallHistory(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 TaskSendWaiting(this, 8 * Monitor.oneSecond, 7 * Monitor.oneSecond)) // Check every 8 seconds but must be 7 seconds old
+    this._tasks.push(new TaskCheckForProofs(this, 2 * Monitor.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 TaskFailAbandoned(this, 8 * Monitor.oneMinute))
     this._tasks.push(new TaskUnFail(this))
-    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
+    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * Monitor.oneHour))
     this._tasks.push(new TaskReviewStatus(this))
+    this._tasks.push(new TaskReorg(this))
   }
 
   /**
@@ -158,13 +190,14 @@ export class Monitor {
     this._tasks.push(new TaskClock(this))
     this._tasks.push(new TaskNewHeader(this))
     this._tasks.push(new TaskMonitorCallHistory(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 TaskSendWaiting(this, 8 * Monitor.oneSecond, 7 * Monitor.oneSecond)) // Check every 8 seconds but must be 7 seconds old
+    this._tasks.push(new TaskCheckForProofs(this, 2 * Monitor.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 TaskFailAbandoned(this, 8 * Monitor.oneMinute))
     this._tasks.push(new TaskUnFail(this))
-    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * this.oneHour))
+    //this._tasks.push(new TaskPurge(this, this.defaultPurgeParams, 6 * Monitor.oneHour))
     this._tasks.push(new TaskReviewStatus(this))
+    this._tasks.push(new TaskReorg(this))
   }
 
   addTask(task: WalletMonitorTask): void {
@@ -177,14 +210,6 @@ export class Monitor {
     this._tasks = this._tasks.filter(t => t.name !== name)
   }
 
-  async setupChaintracksListeners(): Promise<void> {
-    try {
-      // TODO: Use a task monitoring the newest block headere to trigger processNewHeader and reorg handling.
-    } catch (err) {
-      /* this chaintracks doesn't support event subscriptions */
-    }
-  }
-
   async runTask(name: string): Promise<string> {
     let task = this._tasks.find(t => t.name === name)
     let log = ''
@@ -248,17 +273,28 @@ export class Monitor {
   }
 
   _runAsyncSetup: boolean = true
+  _tasksRunningPromise?: PromiseLike<void>
+  resolveCompletion: ((value: void | PromiseLike<void>) => void) | undefined = undefined
 
   async startTasks(): Promise<void> {
     if (this._tasksRunning) throw new WERR_BAD_REQUEST('monitor tasks are already runnining.')
 
     this._tasksRunning = true
+    this._tasksRunningPromise = new Promise(resolve => {
+      this.resolveCompletion = resolve
+    })
+
     for (; this._tasksRunning; ) {
       await this.runOnce()
 
       // console.log(`${new Date().toISOString()} tasks run, waiting...`)
       await wait(this.options.taskRunWaitMsecs)
     }
+
+    if (this.resolveCompletion) {
+      this.resolveCompletion()
+      this.resolveCompletion = undefined
+    }
   }
 
   async logEvent(event: string, details?: string): Promise<void> {
@@ -322,6 +358,8 @@ export class Monitor {
     }
   }
 
+  deactivatedHeaders: DeactivedHeader[] = []
+
   /**
    * Process reorg event received from Chaintracks
    *
@@ -333,7 +371,34 @@ export class Monitor {
    * Coinbase transactions always become invalid.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  processReorg(depth: number, oldTip: BlockHeader, newTip: BlockHeader): void {
-    /* */
+  processReorg(depth: number, oldTip: BlockHeader, newTip: BlockHeader, deactivatedHeaders?: BlockHeader[]): void {
+    if (deactivatedHeaders) {
+      for (const header of deactivatedHeaders) {
+        this.deactivatedHeaders.push({
+          whenMsecs: Date.now(),
+          tries: 0,
+          header
+        })
+      }
+    }
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  processHeader(header: BlockHeader): void {}
+}
+
+export interface DeactivedHeader {
+  /**
+   * To control aging of notification before pursuing updated proof data.
+   */
+  whenMsecs: number
+  /**
+   * Number of attempts made to process the header.
+   * Supports returning deactivation notification to the queue if proof data is not yet available.
+   */
+  tries: number
+  /**
+   * The deactivated block header.
+   */
+  header: BlockHeader
 }

package/src/monitor/MonitorDaemon.ts

@@ -11,6 +11,7 @@ import { Monitor } from './Monitor'
 import { WERR_INTERNAL, WERR_INVALID_PARAMETER } from '../sdk/WERR_errors'
 import { wait } from '../utility/utilityHelpers'
 import { WalletError } from '../sdk/WalletError'
+import { Chaintracks } from '../services/chaintracker/chaintracks/Chaintracks'
 dotenv.config()
 
 const mainDojoConnection = process.env.MAIN_DOJO_CONNECTION || ''
@@ -28,6 +29,7 @@ export interface MonitorDaemonSetup {
   servicesOptions?: WalletServicesOptions
   services?: Services
   monitor?: Monitor
+  chaintracks?: Chaintracks
 }
 
 export class MonitorDaemon {
@@ -99,6 +101,7 @@ export class MonitorDaemon {
       if (a.servicesOptions) {
         if (a.servicesOptions.chain != a.chain)
           throw new WERR_INVALID_PARAMETER('serviceOptions.chain', 'same as args.chain')
+        a.servicesOptions.chaintracks ||= a.chaintracks
         a.services = new Services(a.servicesOptions)
       }
 
@@ -108,7 +111,12 @@ export class MonitorDaemon {
 
       a.storageManager.setServices(a.services)
 
-      const monitorOptions = Monitor.createDefaultWalletMonitorOptions(a.chain, a.storageManager, a.services)
+      const monitorOptions = Monitor.createDefaultWalletMonitorOptions(
+        a.chain,
+        a.storageManager,
+        a.services,
+        a.chaintracks
+      )
       a.monitor = new Monitor(monitorOptions)
     }
 

package/src/monitor/__test/MonitorDaemon.man.test.ts

@@ -1,17 +1,45 @@
-import * as dotenv from 'dotenv'
 import { MonitorDaemon } from '../MonitorDaemon'
-dotenv.config()
-
-const cloudMySQLConnection = process.env.TEST_CLOUD_MYSQL_CONNECTION || '{}'
+import { Chain } from '../../sdk/types'
+import { Services } from '../../services/Services'
+import { _tu } from '../../../test/utils/TestUtilsWalletStorage'
+import { createDefaultNoDbChaintracksOptions } from '../../services/chaintracker/chaintracks/createDefaultNoDbChaintracksOptions'
+import { Chaintracks } from '../../services/chaintracker/chaintracks/Chaintracks'
 
 describe('MonitorDaemon tests', () => {
   jest.setTimeout(99999999)
 
-  test('0', async () => {
+  test('0 mainnet', async () => {
+    await test0Body('main')
+  })
+
+  test('0a testnet', async () => {
+    await test0Body('test')
+  })
+
+  async function test0Body(chain: Chain) {
+    const env = _tu.getEnv(chain)
+
+    const servicesOptions = Services.createDefaultOptions(chain)
+    if (env.taalApiKey) {
+      servicesOptions.taalApiKey = env.taalApiKey
+      servicesOptions.arcConfig.apiKey = env.taalApiKey
+    }
+    if (env.whatsonchainApiKey) servicesOptions.whatsOnChainApiKey = env.whatsonchainApiKey
+    if (env.bitailsApiKey) servicesOptions.bitailsApiKey = env.bitailsApiKey
+
+    const u = undefined
+    const maxRetained = 32
+    const chaintracksOptions = createDefaultNoDbChaintracksOptions(chain, env.whatsonchainApiKey, u, maxRetained)
+    const chaintracks = new Chaintracks(chaintracksOptions)
+    servicesOptions.chaintracks = chaintracks
+
     const d = new MonitorDaemon({
       chain: 'test',
-      mySQLConnection: cloudMySQLConnection
+      mySQLConnection: env.cloudMySQLConnection,
+      servicesOptions,
+      chaintracks
     })
+
     await d.runDaemon()
-  })
+  }
 })

package/src/monitor/tasks/TaskCheckNoSends.ts

@@ -26,7 +26,7 @@ export class TaskCheckNoSends extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = monitor.oneDay * 1
+    public triggerMsecs = Monitor.oneDay * 1
   ) {
     super(monitor, TaskCheckNoSends.taskName)
   }

package/src/monitor/tasks/TaskClock.ts

@@ -7,7 +7,7 @@ export class TaskClock extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = 1 * monitor.oneSecond
+    public triggerMsecs = 1 * Monitor.oneSecond
   ) {
     super(monitor, TaskClock.taskName)
     this.nextMinute = this.getNextMinute()
@@ -28,6 +28,6 @@ export class TaskClock extends WalletMonitorTask {
   }
 
   getNextMinute(): number {
-    return Math.ceil(Date.now() / this.monitor.oneMinute) * this.monitor.oneMinute
+    return Math.ceil(Date.now() / Monitor.oneMinute) * Monitor.oneMinute
   }
 }

package/src/monitor/tasks/TaskMonitorCallHistory.ts

@@ -7,7 +7,7 @@ export class TaskMonitorCallHistory extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = monitor.oneMinute * 12
+    public triggerMsecs = Monitor.oneMinute * 12
   ) {
     super(monitor, TaskMonitorCallHistory.taskName)
   }

package/src/monitor/tasks/TaskNewHeader.ts

@@ -29,7 +29,7 @@ export class TaskNewHeader extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = 1 * monitor.oneMinute
+    public triggerMsecs = 1 * Monitor.oneMinute
   ) {
     super(monitor, TaskNewHeader.taskName)
   }

package/src/monitor/tasks/TaskReorg.ts

@@ -0,0 +1,139 @@
+import { TableProvenTx } from '../../index.client'
+import { BlockHeader } from '../../services/chaintracker/chaintracks/Api/BlockHeaderApi'
+import { DeactivedHeader, Monitor } from '../Monitor'
+import { WalletMonitorTask } from './WalletMonitorTask'
+
+/**
+ * Check the `monitor.deactivatedHeaders` for any headers that have been deactivated.
+ *
+ * When headers are found, review matching ProvenTx records and update proof data as appropriate.
+ *
+ * New deactivated headers are pushed onto the `deactivatedHeaders` array.
+ * They must be shifted out as they are processed.
+ *
+ * The current implementation ages deactivation notifications by 10 minutes with each retry.
+ * If a successful proof update confirms original proof data after 3 retries, the original is retained.
+ *
+ * In normal operation there should never be any work for this task to perform.
+ * The most common result is that there are no matching proven_txs records because
+ * generating new proven_txs records intentionally lags new block generation to
+ * minimize this disruption.
+ *
+ * It is very disruptive to update a proven_txs record because:
+ * - Sync'ed storage is impacted.
+ * - Generated beefs are impacted.
+ * - Updated proof data may be unavailable at the time a reorg is first reported.
+ *
+ * Instead of reorg notification derived from new header notification, reorg repair to
+ * the proven_txs table is more effectively driven by noticing that a beef generated for a new
+ * createAction fails to verify against the chaintracker.
+ *
+ * An alternate approach to processing these events is to revert the proven_txs record to a proven_tx_reqs record.
+ * Pros:
+ * - The same multiple attempt logic that already exists is reused.
+ * - Failing to obtain a new proof already has transaction failure handling in place.
+ * - Generated beefs automatically become one generation deeper, potentially allowing transaction outputs to be spent.
+ * Cons:
+ * - Transactions must revert to un-proven / un-mined.
+ */
+export class TaskReorg extends WalletMonitorTask {
+  static taskName = 'Reorg'
+
+  process: DeactivedHeader[] = []
+
+  constructor(
+    monitor: Monitor,
+    public agedMsecs = Monitor.oneMinute * 10,
+    public maxRetries = 3
+  ) {
+    super(monitor, TaskReorg.taskName)
+  }
+
+  trigger(nowMsecsSinceEpoch: number): { run: boolean } {
+    const cutoff = nowMsecsSinceEpoch - this.agedMsecs
+    const q = this.monitor.deactivatedHeaders
+    while (q.length > 0 && cutoff > q[0].whenMsecs) {
+      // Prepare to process deactivated headers that have aged sufficiently (agedMsecs)
+      const header = q.shift()!
+      this.process.push(header)
+    }
+    return {
+      run: this.process.length > 0
+    }
+  }
+
+  async runTask(): Promise<string> {
+    let log = ''
+
+    for (;;) {
+      const header = this.process.shift()
+      if (!header) break
+
+      let ptxs: TableProvenTx[] = []
+
+      await this.storage.runAsStorageProvider(async sp => {
+        // Lookup all the proven_txs records matching the deactivated headers
+        ptxs = await sp.findProvenTxs({ partial: { blockHash: header.header.hash } })
+      })
+
+      log += `  block ${header.header.hash} orphaned with ${ptxs.length} impacted transactions\n`
+
+      let retry = false
+      for (const ptx of ptxs) {
+        const mpr = await this.monitor.services.getMerklePath(ptx.txid)
+        if (mpr.merklePath && mpr.header) {
+          const mp = mpr.merklePath
+          const h = mpr.header
+          const leaf = mp.path[0].find(leaf => leaf.txid === true && leaf.hash === ptx.txid)
+          if (leaf) {
+            const update: Partial<TableProvenTx> = {
+              height: mp.blockHeight,
+              index: leaf.offset,
+              merklePath: mp.toBinary(),
+              merkleRoot: h.merkleRoot,
+              blockHash: h.hash
+            }
+            if (update.blockHash === ptx.blockHash) {
+              log += `    txid ${ptx.txid} merkle path update still based on deactivated header ${ptx.blockHash}\n`
+              if (header.tries + 1 >= this.maxRetries) {
+                log += `      maximum retries ${this.maxRetries} exceeded\n`
+              } else {
+                retry = true
+              }
+            } else {
+              // Verify the new proof's validity.
+              const merkleRoot = mp.computeRoot(ptx.txid)
+              const chaintracker = await this.monitor.services.getChainTracker()
+              const isValid = await chaintracker.isValidRootForHeight(merkleRoot, update.height!)
+              const logUpdate = `      height ${ptx.height} ${ptx.height === update.height ? 'unchanged' : `-> ${update.height}`}\n`
+              log += `      blockHash ${ptx.blockHash} -> ${update.blockHash}\n`
+              log += `      merkleRoot ${ptx.merkleRoot} -> ${update.merkleRoot}\n`
+              log += `      index ${ptx.index} -> ${update.index}\n`
+              if (!isValid) {
+                log +=
+                  `    txid ${ptx.txid} chaintracker fails to confirm updated merkle path update invalid\n` + logUpdate
+              } else {
+                await this.storage.runAsStorageProvider(async sp => {
+                  await sp.updateProvenTx(ptx.provenTxId, update)
+                })
+                log += `    txid ${ptx.txid} proof data updated\n` + logUpdate
+              }
+            }
+          } else {
+            log += `    txid ${ptx.txid} merkle path update doesn't include txid\n`
+            retry = true
+          }
+        } else {
+          log += `    txid ${ptx.txid} merkle path update unavailable\n`
+          retry = true
+        }
+      }
+      if (retry) {
+        log += `    retrying...\n`
+        this.monitor.deactivatedHeaders.push({ header: header.header, whenMsecs: Date.now(), tries: header.tries + 1 })
+      }
+    }
+
+    return log
+  }
+}

package/src/monitor/tasks/TaskSendWaiting.ts

@@ -16,9 +16,9 @@ export class TaskSendWaiting extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = monitor.oneSecond * 8,
-    public agedMsecs = monitor.oneSecond * 7,
-    public sendingMsecs = monitor.oneMinute * 5
+    public triggerMsecs = Monitor.oneSecond * 8,
+    public agedMsecs = Monitor.oneSecond * 7,
+    public sendingMsecs = Monitor.oneMinute * 5
   ) {
     super(monitor, TaskSendWaiting.taskName)
   }

package/src/monitor/tasks/TaskUnFail.ts

@@ -25,7 +25,7 @@ export class TaskUnFail extends WalletMonitorTask {
 
   constructor(
     monitor: Monitor,
-    public triggerMsecs = monitor.oneMinute * 10
+    public triggerMsecs = Monitor.oneMinute * 10
   ) {
     super(monitor, TaskUnFail.taskName)
   }

package/src/services/chaintracker/chaintracks/Api/ChaintracksClientApi.ts

@@ -10,7 +10,12 @@ export type HeaderListener = (header: BlockHeader) => void
 /**
  * @public
  */
-export type ReorgListener = (depth: number, oldTip: BlockHeader, newTip: BlockHeader) => void
+export type ReorgListener = (
+  depth: number,
+  oldTip: BlockHeader,
+  newTip: BlockHeader,
+  deactivatedHeaders?: BlockHeader[]
+) => void
 
 /**
  * @public

package/src/services/chaintracker/chaintracks/Api/ChaintracksStorageApi.ts

@@ -256,6 +256,10 @@ export type InsertHeaderResult = {
    * If `added` is true, this header was the active chain tip before the insert. It may or may not still be the active chain tip after the insert.
    */
   priorTip: LiveBlockHeader | undefined
+  /**
+   * If a reorg has occurred, these headers where active and are now deactivated.
+   */
+  deactivatedHeaders: LiveBlockHeader[]
   /**
    * header's previousHash was not found in database
    */

package/src/services/chaintracker/chaintracks/Chaintracks.ts

@@ -416,7 +416,9 @@ export class Chaintracks implements ChaintracksManagementApi {
           const reorgListener = this.callbacks.reorg[id]
           if (reorgListener) {
             try {
-              reorgListener(ihr.reorgDepth, ihr.priorTip, header)
+              const priorTip: BlockHeader = { ...ihr.priorTip }
+              const deactivated: BlockHeader[] = ihr.deactivatedHeaders.map(lbh => ({ ...lbh }))
+              reorgListener(ihr.reorgDepth, priorTip, header, deactivated)
             } catch {
               /* ignore all errors thrown */
             }