@bsv/wallet-toolbox 1.6.23 → 1.6.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.6.23",
+  "version": "1.6.25",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -33,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/WalletPermissionsManager.ts

@@ -7,7 +7,9 @@ import {
   WalletProtocol,
   Base64String,
   PubKeyHex,
-  SecurityLevels
+  SecurityLevels,
+  CreateActionInput,
+  Beef
 } from '@bsv/sdk'
 import { validateCreateActionArgs } from './sdk'
 
@@ -656,17 +658,39 @@ export class WalletPermissionsManager implements WalletInterface {
       )
     }
     for (const p of params.granted.protocolPermissions || []) {
-      await this.createPermissionOnChain(
-        {
-          type: 'protocol',
-          originator,
-          privileged: false, // No privileged protocols allowed in groups for added security.
-          protocolID: p.protocolID,
-          counterparty: p.counterparty || 'self',
-          reason: p.description
-        },
-        expiry
+      const token = await this.findProtocolToken(
+        originator,
+        false, // No privileged protocols allowed in groups for added security.
+        p.protocolID,
+        p.counterparty || 'self',
+        true
       )
+      if (token) {
+        await this.renewPermissionOnChain(
+          token,
+          {
+            type: 'protocol',
+            originator,
+            privileged: false, // No privileged protocols allowed in groups for added security.
+            protocolID: p.protocolID,
+            counterparty: p.counterparty || 'self',
+            reason: p.description
+          },
+          expiry
+        )
+      } else {
+        await this.createPermissionOnChain(
+          {
+            type: 'protocol',
+            originator,
+            privileged: false, // No privileged protocols allowed in groups for added security.
+            protocolID: p.protocolID,
+            counterparty: p.counterparty || 'self',
+            reason: p.description
+          },
+          expiry
+        )
+      }
     }
     for (const b of params.granted.basketAccess || []) {
       await this.createPermissionOnChain(
@@ -1335,6 +1359,89 @@ export class WalletPermissionsManager implements WalletInterface {
     return undefined
   }
 
+  /** Finds ALL DPACP permission tokens matching origin/domain, privileged, protocol, cpty. Never filters by expiry. */
+  private async findAllProtocolTokens(
+    originator: string,
+    privileged: boolean,
+    protocolID: WalletProtocol,
+    counterparty: string
+  ): Promise<PermissionToken[]> {
+    const [secLevel, protoName] = protocolID
+    const tags = [
+      `originator ${originator}`,
+      `privileged ${!!privileged}`,
+      `protocolName ${protoName}`,
+      `protocolSecurityLevel ${secLevel}`
+    ]
+    if (secLevel === 2) {
+      tags.push(`counterparty ${counterparty}`)
+    }
+
+    const result = await this.underlying.listOutputs(
+      {
+        basket: BASKET_MAP.protocol,
+        tags,
+        tagQueryMode: 'all',
+        include: 'entire transactions'
+      },
+      this.adminOriginator
+    )
+
+    const matches: PermissionToken[] = []
+
+    for (const out of result.outputs) {
+      const [txid, outputIndexStr] = out.outpoint.split('.')
+      const tx = Transaction.fromBEEF(result.BEEF!, txid)
+      const vout = Number(outputIndexStr)
+      const dec = PushDrop.decode(tx.outputs[vout].lockingScript)
+      if (!dec || !dec.fields || dec.fields.length < 6) continue
+
+      const domainRaw = dec.fields[0]
+      const expiryRaw = dec.fields[1]
+      const privRaw = dec.fields[2]
+      const secLevelRaw = dec.fields[3]
+      const protoNameRaw = dec.fields[4]
+      const counterpartyRaw = dec.fields[5]
+
+      // Decrypt all fields
+      const domainDecoded = Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw))
+      const expiryDecoded = parseInt(Utils.toUTF8(await this.decryptPermissionTokenField(expiryRaw)), 10)
+      const privDecoded = Utils.toUTF8(await this.decryptPermissionTokenField(privRaw)) === 'true'
+      const secLevelDecoded = parseInt(Utils.toUTF8(await this.decryptPermissionTokenField(secLevelRaw)), 10) as
+        | 0
+        | 1
+        | 2
+      const protoNameDecoded = Utils.toUTF8(await this.decryptPermissionTokenField(protoNameRaw))
+      const cptyDecoded = Utils.toUTF8(await this.decryptPermissionTokenField(counterpartyRaw))
+
+      // Strict attribute match; NO expiry filtering
+      if (
+        domainDecoded !== originator ||
+        privDecoded !== !!privileged ||
+        secLevelDecoded !== secLevel ||
+        protoNameDecoded !== protoName ||
+        (secLevelDecoded === 2 && cptyDecoded !== counterparty)
+      ) {
+        continue
+      }
+
+      matches.push({
+        tx: tx.toBEEF(),
+        txid,
+        outputIndex: vout,
+        outputScript: tx.outputs[vout].lockingScript.toHex(),
+        satoshis: out.satoshis,
+        originator,
+        privileged,
+        protocol: protoName,
+        securityLevel: secLevel,
+        expiry: expiryDecoded,
+        counterparty: cptyDecoded
+      })
+    }
+
+    return matches
+  }
   /** Looks for a DBAP token matching (originator, basket). */
   private async findBasketToken(
     originator: string,
@@ -1569,6 +1676,70 @@ export class WalletPermissionsManager implements WalletInterface {
     )
   }
 
+  private async coalescePermissionTokens(
+    oldTokens: PermissionToken[],
+    newScript: LockingScript,
+    opts?: {
+      tags?: string[]
+      basket?: string
+      description?: string
+    }
+  ): Promise<string> {
+    if (!oldTokens?.length) throw new Error('No permission tokens to coalesce')
+    if (oldTokens.length < 2) throw new Error('Need at least 2 tokens to coalesce')
+
+    // 1) Create a signable action with N inputs and a single renewed output
+    const { signableTransaction } = await this.createAction(
+      {
+        description: opts?.description ?? `Coalesce ${oldTokens.length} permission tokens`,
+        inputs: oldTokens.map((t, i) => ({
+          outpoint: `${t.txid}.${t.outputIndex}`,
+          unlockingScriptLength: 74,
+          inputDescription: `Consume permission token #${i + 1}`
+        })),
+        outputs: [
+          {
+            lockingScript: newScript.toHex(),
+            satoshis: 1,
+            outputDescription: 'Renewed permission token',
+            ...(opts?.basket ? { basket: opts.basket } : {}),
+            ...(opts?.tags ? { tags: opts.tags } : {})
+          }
+        ],
+        options: {
+          acceptDelayedBroadcast: false,
+          randomizeOutputs: false,
+          signAndProcess: false
+        }
+      },
+      this.adminOriginator
+    )
+
+    if (!signableTransaction?.reference || !signableTransaction.tx) {
+      throw new Error('Failed to create signable transaction')
+    }
+
+    // 2) Sign each input
+    const partialTx = Transaction.fromAtomicBEEF(signableTransaction.tx)
+    const pushdrop = new PushDrop(this.underlying)
+    const unlocker = pushdrop.unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self')
+
+    const spends: Record<number, { unlockingScript: string }> = {}
+    for (let i = 0; i < oldTokens.length; i++) {
+      // The signable transaction already contains the necessary prevout context
+      const unlockingScript = await unlocker.sign(partialTx, i)
+      spends[i] = { unlockingScript: unlockingScript.toHex() }
+    }
+
+    // 3) Finalize the action
+    const { txid } = await this.underlying.signAction({
+      reference: signableTransaction.reference,
+      spends
+    })
+
+    if (!txid) throw new Error('Failed to finalize coalescing transaction')
+    return txid
+  }
   /**
    * Renews a permission token by spending the old token as input and creating a new token output.
    * This invalidates the old token and replaces it with a new one.
@@ -1596,57 +1767,74 @@ export class WalletPermissionsManager implements WalletInterface {
       true,
       true
     )
-
     const tags = this.buildTagsForRequest(r)
+    // Check if there are multiple old tokens for the same parameters (shouldn't usually happen)
+    const oldTokens = await this.findAllProtocolTokens(
+      oldToken.originator,
+      oldToken.privileged!,
+      [oldToken.securityLevel!, oldToken.protocol!],
+      oldToken.counterparty!
+    )
 
-    // 3) For BRC-100, we do a "createAction" with a partial input referencing oldToken
-    //    plus a single new output. We'll hydrate the template, then signAction for the wallet to finalize.
-    const oldOutpoint = `${oldToken.txid}.${oldToken.outputIndex}`
-    const { signableTransaction } = await this.createAction(
-      {
-        description: `Renew ${r.type} permission`,
-        inputBEEF: oldToken.tx,
-        inputs: [
-          {
-            outpoint: oldOutpoint,
-            unlockingScriptLength: 73, // length of signature
-            inputDescription: `Consume old ${r.type} token`
+    // If so, coalesce them into a single token first, to avoid bloat
+    if (oldTokens.length > 1) {
+      const txid = await this.coalescePermissionTokens(oldTokens, newScript, {
+        tags,
+        basket: BASKET_MAP[r.type],
+        description: `Coalesce ${r.type} permission tokens`
+      })
+      console.log('Coalesced permission tokens:', txid)
+    } else {
+      // Otherwise, just proceed with the single-token renewal
+      // 3) For BRC-100, we do a "createAction" with a partial input referencing oldToken
+      //    plus a single new output. We'll hydrate the template, then signAction for the wallet to finalize.
+      const oldOutpoint = `${oldToken.txid}.${oldToken.outputIndex}`
+      const { signableTransaction } = await this.createAction(
+        {
+          description: `Renew ${r.type} permission`,
+          inputBEEF: oldToken.tx,
+          inputs: [
+            {
+              outpoint: oldOutpoint,
+              unlockingScriptLength: 73, // length of signature
+              inputDescription: `Consume old ${r.type} token`
+            }
+          ],
+          outputs: [
+            {
+              lockingScript: newScript.toHex(),
+              satoshis: 1,
+              outputDescription: `Renewed ${r.type} permission token`,
+              basket: BASKET_MAP[r.type],
+              tags
+            }
+          ],
+          options: {
+            acceptDelayedBroadcast: false
           }
-        ],
-        outputs: [
-          {
-            lockingScript: newScript.toHex(),
-            satoshis: 1,
-            outputDescription: `Renewed ${r.type} permission token`,
-            basket: BASKET_MAP[r.type],
-            tags
+        },
+        this.adminOriginator
+      )
+      const tx = Transaction.fromBEEF(signableTransaction!.tx)
+      const unlocker = new PushDrop(this.underlying).unlock(
+        WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL,
+        '1',
+        'self',
+        'all',
+        false,
+        1,
+        LockingScript.fromHex(oldToken.outputScript)
+      )
+      const unlockingScript = await unlocker.sign(tx, 0)
+      await this.underlying.signAction({
+        reference: signableTransaction!.reference,
+        spends: {
+          0: {
+            unlockingScript: unlockingScript.toHex()
           }
-        ],
-        options: {
-          acceptDelayedBroadcast: false
-        }
-      },
-      this.adminOriginator
-    )
-    const tx = Transaction.fromBEEF(signableTransaction!.tx)
-    const unlocker = new PushDrop(this.underlying).unlock(
-      WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL,
-      '1',
-      'self',
-      'all',
-      false,
-      1,
-      LockingScript.fromHex(oldToken.outputScript)
-    )
-    const unlockingScript = await unlocker.sign(tx, 0)
-    await this.underlying.signAction({
-      reference: signableTransaction!.reference,
-      spends: {
-        0: {
-          unlockingScript: unlockingScript.toHex()
         }
-      }
-    })
+      })
+    }
   }
 
   /**

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)
     }