Struct Monitor 

pub struct Monitor {
    pub options: MonitorOptions,
    pub storage: WalletStorageManager,
    pub services: Arc<dyn WalletServices>,
    pub chain: Chain,
    pub check_now: Arc<AtomicBool>,
    pub last_new_header_height: Arc<AtomicU32>,
    pub last_new_header: Option<BlockHeader>,
    pub last_new_header_when: Option<u64>,
    pub deactivated_headers: Arc<Mutex<Vec<DeactivatedHeader>>>,
    /* private fields */
}

Background task scheduler that manages transaction lifecycle.

Automatically handles broadcasting pending transactions, collecting merkle proofs, detecting chain reorgs, failing stale transactions, and cleaning up old data.

Translated from TS Monitor class in wallet-toolbox/src/monitor/Monitor.ts.

NOTE: Tasks run sequentially within each polling iteration, matching the TS pattern. Concurrent task execution is a future optimization.

Fields

options: MonitorOptions

Configuration options.

storage: WalletStorageManager

Storage manager for persistence operations.

services: Arc<dyn WalletServices>

Network services for broadcasting and proof retrieval.

chain: Chain

The chain this monitor is configured for.

check_now: Arc<AtomicBool>

Flag to nudge proof checking (set by processNewBlockHeader). Shared with TaskCheckForProofs.

last_new_header_height: Arc<AtomicU32>

Shared last header height for max acceptable height guard. u32::MAX is the sentinel for “no height known”. Shared with TaskCheckForProofs and updated in process_new_block_header.

last_new_header: Option<BlockHeader>

The last new block header received.

last_new_header_when: Option<u64>

When the last new header was received (epoch ms).

deactivated_headers: Arc<Mutex<Vec<DeactivatedHeader>>>

Queue of deactivated headers from reorg events, awaiting processing.

Implementations

impl Monitor

pub fn builder() -> MonitorBuilder

Returns a new MonitorBuilder for fluent construction.

pub fn start_tasks(&mut self) -> WalletResult<()>

Start the polling loop in a background tokio task.

Validates that the monitor is not already running, then spawns the loop.

pub async fn stop_tasks(&mut self)

Stop the polling loop and wait for it to complete.

pub async fn destroy(&mut self)

Destroy the monitor: stops tasks and cleans up subscriptions.

pub async fn run_once(&mut self) -> WalletResult<()>

Run one iteration of the polling loop (for testing).

Runs async_setup on first call, then triggers and runs tasks once.

pub async fn run_task(&mut self, name: &str) -> WalletResult<String>

Run a specific task by name (from _tasks or _otherTasks).

pub fn process_new_block_header(&mut self, header: BlockHeader)

Process a new block header event received from Chaintracks.

Stores the header and nudges the proof checker to try again.

pub async fn process_reorg( &self, _depth: u32, _old_tip: &BlockHeader, _new_tip: &BlockHeader, deactivated: Option<&[BlockHeader]>, )

Process a reorg event received from Chaintracks.

Reorgs can move recent transactions to new blocks at new index positions. Affected transaction proofs become invalid and must be updated.

pub fn process_header(&self, _header: &BlockHeader)

Handler for new header events from Chaintracks.

To minimize reorg processing, new headers are aged before processing via TaskNewHeader. Therefore this handler is intentionally a no-op.

pub async fn call_on_broadcasted_transaction(&self, broadcast_result: &str)

Call the on_tx_broadcasted callback if registered.

pub async fn call_on_proven_transaction(&self, tx_status: &str)

Call the on_tx_proven callback if registered.

pub async fn call_on_transaction_status_changed( &self, txid: &str, new_status: &str, )

Call the on_tx_status_changed callback if registered.

pub fn is_running(&self) -> bool

Returns whether the monitor is currently running.

pub fn add_task(&mut self, task: Box<dyn WalletMonitorTask>) -> WalletResult<()>

Add a task to the scheduled task list.

pub fn remove_task(&mut self, name: &str)

Remove a task from the scheduled task list by name.