@bsv/wallet-toolbox-client/out/src/monitor/Monitor.d.ts

Client only Wallet Storage

import { WalletMonitorTask } from './tasks/WalletMonitorTask';
import { WalletStorageManager } from '../storage/WalletStorageManager';
import { TaskPurgeParams } from './tasks/TaskPurge';
import { Chain, ProvenTransactionStatus } from '../sdk/types';
import { ChaintracksServiceClient } from '../services/chaintracker/chaintracks/ChaintracksServiceClient';
import { ReviewActionResult } from '../sdk/WalletStorage.interfaces';
import { BlockHeader } from '../sdk/WalletServices.interfaces';
import { Services } from '../services/Services';
export type MonitorStorage = WalletStorageManager;
export interface MonitorOptions {
    chain: Chain;
    services: Services;
    storage: MonitorStorage;
    chaintracks: ChaintracksServiceClient;
    /**
     * How many msecs to wait after each getMerkleProof service request.
     */
    msecsWaitPerMerkleProofServiceReq: number;
    taskRunWaitMsecs: number;
    abandonedMsecs: number;
    unprovenAttemptsLimitTest: number;
    unprovenAttemptsLimitMain: number;
    /**
     * These are hooks for a wallet-toolbox client to get transaction updates.
     */
    onTransactionBroadcasted?: (broadcastResult: ReviewActionResult) => Promise<void>;
    onTransactionProven?: (txStatus: ProvenTransactionStatus) => Promise<void>;
}
/**
 * Background task to make sure transactions are processed, transaction proofs are received and propagated,
 * and potentially that reorgs update proofs that were already received.
 */
export declare class Monitor {
    static createDefaultWalletMonitorOptions(chain: Chain, storage: MonitorStorage, services?: Services): MonitorOptions;
    options: MonitorOptions;
    services: Services;
    chain: Chain;
    storage: MonitorStorage;
    chaintracks: ChaintracksServiceClient;
    onTransactionBroadcasted?: (broadcastResult: ReviewActionResult) => Promise<void>;
    onTransactionProven?: (txStatus: ProvenTransactionStatus) => Promise<void>;
    constructor(options: MonitorOptions);
    oneSecond: number;
    oneMinute: number;
    oneHour: number;
    oneDay: number;
    oneWeek: number;
    /**
     * _tasks are typically run by the scheduler but may also be run by runTask.
     */
    _tasks: WalletMonitorTask[];
    /**
     * _otherTasks can be run by runTask but not by scheduler.
     */
    _otherTasks: WalletMonitorTask[];
    _tasksRunning: boolean;
    defaultPurgeParams: TaskPurgeParams;
    addAllTasksToOther(): void;
    /**
     * Default tasks with settings appropriate for a single user storage
     * possibly with sync'ing enabled
     */
    addDefaultTasks(): void;
    /**
     * Tasks appropriate for multi-user storage
     * without sync'ing enabled.
     */
    addMultiUserTasks(): void;
    addTask(task: WalletMonitorTask): void;
    removeTask(name: string): void;
    setupChaintracksListeners(): Promise<void>;
    runTask(name: string): Promise<string>;
    runOnce(): Promise<void>;
    _runAsyncSetup: boolean;
    startTasks(): Promise<void>;
    logEvent(event: string, details?: string): Promise<void>;
    stopTasks(): void;
    lastNewHeader: BlockHeader | undefined;
    lastNewHeaderWhen: Date | undefined;
    /**
     * Process new chain header event received from Chaintracks
     *
     * Kicks processing 'unconfirmed' and 'unmined' request processing.
     *
     * @param reqs
     */
    processNewBlockHeader(header: BlockHeader): void;
    /**
     * 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: ReviewActionResult): void;
    /**
     * 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: ProvenTransactionStatus): void;
    /**
     * Process 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.
     *
     * It is possible for a transaction to become invalid.
     *
     * Coinbase transactions always become invalid.
     */
    processReorg(depth: number, oldTip: BlockHeader, newTip: BlockHeader): void;
}
//# sourceMappingURL=Monitor.d.ts.map