@bsv/wallet-toolbox-client 1.7.15 → 1.7.16

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

@@ -0,0 +1,101 @@
+import { ChaintracksOptions, ChaintracksManagementApi } from './Api/ChaintracksApi';
+import { Chain } from '../../../sdk/types';
+import { ChaintracksInfoApi, HeaderListener, ReorgListener } from './Api/ChaintracksClientApi';
+import { BaseBlockHeader, BlockHeader, LiveBlockHeader } from './Api/BlockHeaderApi';
+import { ChaintracksFsApi } from './Api/ChaintracksFsApi';
+export declare class Chaintracks implements ChaintracksManagementApi {
+    options: ChaintracksOptions;
+    static createOptions(chain: Chain): ChaintracksOptions;
+    log: (...args: any[]) => void;
+    readonly chain: Chain;
+    readonly readonly: boolean;
+    private promises;
+    private callbacks;
+    private storage;
+    private bulkIngestors;
+    private liveIngestors;
+    private baseHeaders;
+    private liveHeaders;
+    private addLiveRecursionLimit;
+    private available;
+    private startupError;
+    private subscriberCallbacksEnabled;
+    private stopMainThread;
+    private lastPresentHeight;
+    private lastPresentHeightMsecs;
+    private lastPresentHeightMaxAge;
+    private lock;
+    constructor(options: ChaintracksOptions);
+    getChain(): Promise<Chain>;
+    /**
+     * Caches and returns most recently sourced value if less than one minute old.
+     * @returns the current externally available chain height (via bulk ingestors).
+     */
+    getPresentHeight(): Promise<number>;
+    currentHeight(): Promise<number>;
+    subscribeHeaders(listener: HeaderListener): Promise<string>;
+    subscribeReorgs(listener: ReorgListener): Promise<string>;
+    unsubscribe(subscriptionId: string): Promise<boolean>;
+    /**
+     * Queues a potentially new, unknown header for consideration as an addition to the chain.
+     * When the header is considered, if the prior header is unknown, recursive calls to the
+     * bulk ingestors will be attempted to resolve the linkage up to a depth of `addLiveRecursionLimit`.
+     *
+     * Headers are considered in the order they were added.
+     *
+     * @param header
+     */
+    addHeader(header: BaseBlockHeader): Promise<void>;
+    /**
+     * If not already available, takes a writer lock to queue calls until available.
+     * Becoming available starts by initializing ingestors and main thread,
+     * and ends when main thread sets `available`.
+     * Note that the main thread continues running and takes additional write locks
+     * itself when already available.
+     *
+     * @returns when available for client requests
+     */
+    makeAvailable(): Promise<void>;
+    startPromises(): Promise<void>;
+    destroy(): Promise<void>;
+    listening(): Promise<void>;
+    isListening(): Promise<boolean>;
+    isSynchronized(): Promise<boolean>;
+    findHeaderForHeight(height: number): Promise<BlockHeader | undefined>;
+    private findHeaderForHeightNoLock;
+    findHeaderForBlockHash(hash: string): Promise<BlockHeader | undefined>;
+    private findHeaderForBlockHashNoLock;
+    isValidRootForHeight(root: string, height: number): Promise<boolean>;
+    getInfo(): Promise<ChaintracksInfoApi>;
+    private getInfoNoLock;
+    getHeaders(height: number, count: number): Promise<string>;
+    findChainTipHeader(): Promise<BlockHeader>;
+    findChainTipHash(): Promise<string>;
+    findLiveHeaderForBlockHash(hash: string): Promise<LiveBlockHeader | undefined>;
+    findChainWorkForBlockHash(hash: string): Promise<string | undefined>;
+    /**
+     * @returns true iff all headers from height zero through current chainTipHeader height can be retreived and form a valid chain.
+     */
+    validate(): Promise<boolean>;
+    exportBulkHeaders(toFolder: string, toFs: ChaintracksFsApi, sourceUrl?: string, toHeadersPerFile?: number, maxHeight?: number): Promise<void>;
+    startListening(): Promise<void>;
+    private syncBulkStorage;
+    private syncBulkStorageNoLock;
+    private getMissingBlockHeader;
+    private invalidInsertHeaderResult;
+    private addLiveHeader;
+    /**
+     * Long running method terminated by setting `stopMainThread` false.
+     *
+     * The promise returned by this method is held in the `promises` array.
+     *
+     * When synchronized (bulk and live storage is valid up to most recent presentHeight),
+     * this method will process headers from `baseHeaders` and `liveHeaders` arrays to extend the chain of headers.
+     *
+     * If a significant gap is detected between bulk+live and presentHeight, `syncBulkStorage` is called to re-establish sync.
+     *
+     * Periodically CDN bulk ingestor is invoked to check if incremental headers can be migrated to CDN backed files.
+     */
+    private mainThreadShiftLiveHeaders;
+}
+//# sourceMappingURL=Chaintracks.d.ts.map

package/out/src/services/chaintracker/chaintracks/Chaintracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chaintracks.d.ts","sourceRoot":"","sources":["../../../../../../src/services/chaintracker/chaintracks/Chaintracks.ts"],"names":[],"mappings":"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"}

package/out/src/services/chaintracker/chaintracks/Chaintracks.js

@@ -0,0 +1,550 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chaintracks = void 0;
+const dirtyHashes_1 = require("./util/dirtyHashes");
+const blockHeaderUtilities_1 = require("./util/blockHeaderUtilities");
+const utilityHelpers_noBuffer_1 = require("../../../utility/utilityHelpers.noBuffer");
+const HeightRange_1 = require("./util/HeightRange");
+const SingleWriterMultiReaderLock_1 = require("./util/SingleWriterMultiReaderLock");
+const utilityHelpers_1 = require("../../../utility/utilityHelpers");
+const WalletError_1 = require("../../../sdk/WalletError");
+class Chaintracks {
+    static createOptions(chain) {
+        return {
+            chain,
+            storage: undefined,
+            bulkIngestors: [],
+            liveIngestors: [],
+            addLiveRecursionLimit: 36,
+            logging: (...args) => console.log(new Date().toISOString(), ...args),
+            readonly: false
+        };
+    }
+    constructor(options) {
+        this.options = options;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.log = () => { };
+        // Collection of all long running "threads": main thread (liveHeaders consumer / monitor) and each live header ingestor.
+        this.promises = [];
+        this.callbacks = { header: [], reorg: [] };
+        this.baseHeaders = [];
+        this.liveHeaders = [];
+        this.addLiveRecursionLimit = 11;
+        this.available = false;
+        this.startupError = null;
+        this.subscriberCallbacksEnabled = false;
+        this.stopMainThread = true;
+        this.lastPresentHeight = 0;
+        this.lastPresentHeightMsecs = 0;
+        this.lastPresentHeightMaxAge = 60 * 1000; // 1 minute, in milliseconds
+        this.lock = new SingleWriterMultiReaderLock_1.SingleWriterMultiReaderLock();
+        if (!options.storage)
+            throw new Error('storage is required.');
+        if (!options.bulkIngestors || options.bulkIngestors.length < 1)
+            throw new Error('At least one bulk ingestor is required.');
+        if (!options.liveIngestors || options.liveIngestors.length < 1)
+            throw new Error('At least one live ingestor is required.');
+        this.chain = options.chain;
+        this.readonly = options.readonly;
+        this.storage = options.storage;
+        this.bulkIngestors = options.bulkIngestors;
+        this.liveIngestors = options.liveIngestors;
+        this.addLiveRecursionLimit = options.addLiveRecursionLimit;
+        if (options.logging)
+            this.log = options.logging;
+        this.storage.log = this.log;
+        this.log(`New ChaintracksBase Instance Constructed ${options.chain}Net`);
+    }
+    async getChain() {
+        return this.chain;
+    }
+    /**
+     * Caches and returns most recently sourced value if less than one minute old.
+     * @returns the current externally available chain height (via bulk ingestors).
+     */
+    async getPresentHeight() {
+        const now = Date.now();
+        if (this.lastPresentHeight && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) {
+            return this.lastPresentHeight;
+        }
+        const presentHeights = [];
+        for (const bulk of this.bulkIngestors) {
+            try {
+                const presentHeight = await bulk.getPresentHeight();
+                if (presentHeight)
+                    presentHeights.push(presentHeight);
+            }
+            catch (uerr) {
+                console.error(uerr);
+            }
+        }
+        const presentHeight = presentHeights.length ? Math.max(...presentHeights) : undefined;
+        if (!presentHeight)
+            throw new Error('At least one bulk ingestor must implement getPresentHeight.');
+        this.lastPresentHeight = presentHeight;
+        this.lastPresentHeightMsecs = now;
+        return presentHeight;
+    }
+    async currentHeight() {
+        return await this.getPresentHeight();
+    }
+    async subscribeHeaders(listener) {
+        const ID = (0, utilityHelpers_1.randomBytesBase64)(8);
+        this.callbacks.header[ID] = listener;
+        return ID;
+    }
+    async subscribeReorgs(listener) {
+        const ID = (0, utilityHelpers_1.randomBytesBase64)(8);
+        this.callbacks.reorg[ID] = listener;
+        return ID;
+    }
+    async unsubscribe(subscriptionId) {
+        let success = true;
+        if (this.callbacks.header[subscriptionId])
+            delete this.callbacks.header[subscriptionId];
+        else if (this.callbacks.reorg[subscriptionId])
+            delete this.callbacks.reorg[subscriptionId];
+        else
+            success = false;
+        return success;
+    }
+    /**
+     * Queues a potentially new, unknown header for consideration as an addition to the chain.
+     * When the header is considered, if the prior header is unknown, recursive calls to the
+     * bulk ingestors will be attempted to resolve the linkage up to a depth of `addLiveRecursionLimit`.
+     *
+     * Headers are considered in the order they were added.
+     *
+     * @param header
+     */
+    async addHeader(header) {
+        this.baseHeaders.push(header);
+    }
+    /**
+     * If not already available, takes a writer lock to queue calls until available.
+     * Becoming available starts by initializing ingestors and main thread,
+     * and ends when main thread sets `available`.
+     * Note that the main thread continues running and takes additional write locks
+     * itself when already available.
+     *
+     * @returns when available for client requests
+     */
+    async makeAvailable() {
+        if (this.available)
+            return;
+        await this.lock.withWriteLock(async () => {
+            // Only the first call proceeds to initialize...
+            if (this.available)
+                return;
+            // Make sure database schema exists and is updated...
+            await this.storage.migrateLatest();
+            for (const bulkIn of this.bulkIngestors)
+                await bulkIn.setStorage(this.storage, this.log);
+            for (const liveIn of this.liveIngestors)
+                await liveIn.setStorage(this.storage, this.log);
+            // Start all live ingestors to push new headers onto liveHeaders... each long running.
+            for (const liveIngestor of this.liveIngestors)
+                this.promises.push(liveIngestor.startListening(this.liveHeaders));
+            // Start mai loop to shift out liveHeaders...once sync'd, will set `available` true.
+            this.promises.push(this.mainThreadShiftLiveHeaders());
+            // Wait for the main thread to finish initial sync.
+            while (!this.available && !this.startupError) {
+                await (0, utilityHelpers_1.wait)(100);
+            }
+            if (this.startupError)
+                throw this.startupError;
+        });
+    }
+    async startPromises() {
+        if (this.promises.length > 0 || this.stopMainThread !== true)
+            return;
+    }
+    async destroy() {
+        if (!this.available)
+            return;
+        await this.lock.withWriteLock(async () => {
+            if (!this.available || this.stopMainThread)
+                return;
+            this.log('Shutting Down');
+            this.stopMainThread = true;
+            for (const liveIn of this.liveIngestors)
+                await liveIn.shutdown();
+            for (const bulkIn of this.bulkIngestors)
+                await bulkIn.shutdown();
+            await Promise.all(this.promises);
+            await this.storage.destroy();
+            this.available = false;
+            this.stopMainThread = false;
+            this.log('Shutdown');
+        });
+    }
+    async listening() {
+        return this.makeAvailable();
+    }
+    async isListening() {
+        return this.available;
+    }
+    async isSynchronized() {
+        await this.makeAvailable();
+        // TODO add synchronized flag... false while bulksyncing...
+        return true;
+    }
+    async findHeaderForHeight(height) {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => this.findHeaderForHeightNoLock(height));
+    }
+    async findHeaderForHeightNoLock(height) {
+        return await this.storage.findHeaderForHeightOrUndefined(height);
+    }
+    async findHeaderForBlockHash(hash) {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => this.findHeaderForBlockHashNoLock(hash));
+    }
+    async findHeaderForBlockHashNoLock(hash) {
+        return (await this.storage.findLiveHeaderForBlockHash(hash)) || undefined;
+    }
+    async isValidRootForHeight(root, height) {
+        const r = await this.findHeaderForHeight(height);
+        if (!r)
+            return false;
+        const isValid = root === r.merkleRoot;
+        return isValid;
+    }
+    async getInfo() {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => this.getInfoNoLock());
+    }
+    async getInfoNoLock() {
+        const liveRange = await this.storage.findLiveHeightRange();
+        const info = {
+            chain: this.chain,
+            heightBulk: liveRange.minHeight - 1,
+            heightLive: liveRange.maxHeight,
+            storage: this.storage.constructor.name,
+            bulkIngestors: this.bulkIngestors.map(bulkIngestor => bulkIngestor.constructor.name),
+            liveIngestors: this.liveIngestors.map(liveIngestor => liveIngestor.constructor.name),
+            packages: []
+        };
+        return info;
+    }
+    async getHeaders(height, count) {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => (0, utilityHelpers_noBuffer_1.asString)(await this.storage.getHeadersUint8Array(height, count)));
+    }
+    async findChainTipHeader() {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => await this.storage.findChainTipHeader());
+    }
+    async findChainTipHash() {
+        await this.makeAvailable();
+        return this.lock.withReadLock(async () => await this.storage.findChainTipHash());
+    }
+    async findLiveHeaderForBlockHash(hash) {
+        await this.makeAvailable();
+        const header = await this.lock.withReadLock(async () => await this.storage.findLiveHeaderForBlockHash(hash));
+        return header || undefined;
+    }
+    async findChainWorkForBlockHash(hash) {
+        const header = await this.findLiveHeaderForBlockHash(hash);
+        return header === null || header === void 0 ? void 0 : header.chainWork;
+    }
+    /**
+     * @returns true iff all headers from height zero through current chainTipHeader height can be retreived and form a valid chain.
+     */
+    async validate() {
+        let h = await this.findChainTipHeader();
+        while (h.height > 0) {
+            const hp = await this.findHeaderForHeight(h.height - 1);
+            if (!hp || hp.hash !== h.previousHash)
+                throw new Error(`validation fails at height ${h.height}`);
+            h = hp;
+            if (10000 * Math.floor(h.height / 10000) === h.height)
+                this.log(`height ${h.height}`);
+        }
+        this.log('validated');
+        return true;
+    }
+    async exportBulkHeaders(toFolder, toFs, sourceUrl, toHeadersPerFile, maxHeight) {
+        toHeadersPerFile || (toHeadersPerFile = 100000);
+        const bulk = this.storage.bulkManager;
+        await bulk.exportHeadersToFs(toFs, toHeadersPerFile, toFolder, sourceUrl, maxHeight);
+    }
+    async startListening() {
+        this.makeAvailable();
+    }
+    async syncBulkStorage(presentHeight, initialRanges) {
+        await this.lock.withWriteLock(async () => await this.syncBulkStorageNoLock(presentHeight, initialRanges));
+    }
+    async syncBulkStorageNoLock(presentHeight, initialRanges) {
+        let newLiveHeaders = [];
+        let bulkDone = false;
+        let before = initialRanges;
+        let after = before;
+        let added = HeightRange_1.HeightRange.empty;
+        let done = false;
+        for (; !done;) {
+            let bulkSyncError;
+            for (const bulk of this.bulkIngestors) {
+                try {
+                    const r = await bulk.synchronize(presentHeight, before, newLiveHeaders);
+                    newLiveHeaders = r.liveHeaders;
+                    after = await this.storage.getAvailableHeightRanges();
+                    added = after.bulk.above(before.bulk);
+                    before = after;
+                    this.log(`Bulk Ingestor: ${added.length} added with ${newLiveHeaders.length} live headers from ${bulk.constructor.name}`);
+                    if (r.done) {
+                        done = true;
+                        break;
+                    }
+                }
+                catch (eu) {
+                    const e = (bulkSyncError = WalletError_1.WalletError.fromUnknown(eu));
+                    this.log(`bulk sync error: ${e.message}`);
+                    if (!this.available)
+                        // During initial startup, bulk ingestors must be available.
+                        break;
+                }
+            }
+            if (!bulkDone && !this.available && bulkSyncError) {
+                this.startupError = bulkSyncError;
+                break;
+            }
+            if (bulkDone)
+                break;
+        }
+        if (!this.startupError) {
+            this.liveHeaders.unshift(...newLiveHeaders);
+            added = after.bulk.above(initialRanges.bulk);
+            this.log(`syncBulkStorage done
+  Before sync: bulk ${initialRanges.bulk}, live ${initialRanges.live}
+   After sync: bulk ${after.bulk}, live ${after.live}
+  ${added.length} headers added to bulk storage
+  ${this.liveHeaders.length} headers forwarded to live header storage
+`);
+        }
+    }
+    async getMissingBlockHeader(hash) {
+        for (const live of this.liveIngestors) {
+            const header = await live.getHeaderByHash(hash);
+            if (header)
+                return header;
+        }
+        return undefined;
+    }
+    invalidInsertHeaderResult(ihr) {
+        return ihr.noActiveAncestor || ihr.noTip || ihr.badPrev;
+    }
+    async addLiveHeader(header) {
+        (0, blockHeaderUtilities_1.validateHeaderFormat)(header);
+        (0, dirtyHashes_1.validateAgainstDirtyHashes)(header.hash);
+        const ihr = this.available
+            ? await this.lock.withWriteLock(async () => await this.storage.insertHeader(header))
+            : await this.storage.insertHeader(header);
+        if (this.invalidInsertHeaderResult(ihr))
+            return ihr;
+        if (this.subscriberCallbacksEnabled && ihr.added && ihr.isActiveTip) {
+            // If a new active chaintip has been added, notify subscribed event listeners...
+            for (const id in this.callbacks.header) {
+                const addListener = this.callbacks.header[id];
+                if (addListener) {
+                    try {
+                        addListener(header);
+                    }
+                    catch (_a) {
+                        /* ignore all errors thrown */
+                    }
+                }
+            }
+            if (ihr.reorgDepth > 0 && ihr.priorTip) {
+                // If the new header was also a reorg, notify subscribed event listeners...
+                for (const id in this.callbacks.reorg) {
+                    const reorgListener = this.callbacks.reorg[id];
+                    if (reorgListener) {
+                        try {
+                            const priorTip = { ...ihr.priorTip };
+                            const deactivated = ihr.deactivatedHeaders.map(lbh => ({ ...lbh }));
+                            reorgListener(ihr.reorgDepth, priorTip, header, deactivated);
+                        }
+                        catch (_b) {
+                            /* ignore all errors thrown */
+                        }
+                    }
+                }
+            }
+        }
+        return ihr;
+    }
+    /**
+     * Long running method terminated by setting `stopMainThread` false.
+     *
+     * The promise returned by this method is held in the `promises` array.
+     *
+     * When synchronized (bulk and live storage is valid up to most recent presentHeight),
+     * this method will process headers from `baseHeaders` and `liveHeaders` arrays to extend the chain of headers.
+     *
+     * If a significant gap is detected between bulk+live and presentHeight, `syncBulkStorage` is called to re-establish sync.
+     *
+     * Periodically CDN bulk ingestor is invoked to check if incremental headers can be migrated to CDN backed files.
+     */
+    async mainThreadShiftLiveHeaders() {
+        this.stopMainThread = false;
+        let lastSyncCheck = Date.now();
+        let lastBulkSync = Date.now();
+        const cdnSyncRepeatMsecs = 24 * 60 * 60 * 1000; // 24 hours
+        const syncCheckRepeatMsecs = 30 * 60 * 1000; // 30 minutes
+        while (!this.stopMainThread) {
+            try {
+                // Review the need for bulk sync...
+                const now = Date.now();
+                lastSyncCheck = now;
+                const presentHeight = await this.getPresentHeight();
+                const before = await this.storage.getAvailableHeightRanges();
+                // Skip bulk sync if within less than half the recursion limit of present height
+                let skipBulkSync = !before.live.isEmpty && before.live.maxHeight >= presentHeight - this.addLiveRecursionLimit / 2;
+                if (skipBulkSync && now - lastBulkSync > cdnSyncRepeatMsecs) {
+                    // If we haven't re-synced in a long time, do it just to check for a CDN update.
+                    skipBulkSync = false;
+                }
+                this.log(`Chaintracks Update Services: Bulk Header Sync Review
+  presentHeight=${presentHeight}   addLiveRecursionLimit=${this.addLiveRecursionLimit}
+  Before synchronize: bulk ${before.bulk}, live ${before.live}
+  ${skipBulkSync ? 'Skipping' : 'Starting'} syncBulkStorage.
+`);
+                if (!skipBulkSync) {
+                    // Bring bulk storage up-to-date and (re-)initialize liveHeaders
+                    lastBulkSync = now;
+                    if (this.available)
+                        // Once available, initial write lock is released, take a new one to update bulk storage.
+                        await this.syncBulkStorage(presentHeight, before);
+                    else
+                        // While still not available, the makeAvailable write lock is held.
+                        await this.syncBulkStorageNoLock(presentHeight, before);
+                    if (this.startupError)
+                        throw this.startupError;
+                }
+                let count = 0;
+                let liveHeaderDupes = 0;
+                let needSyncCheck = false;
+                for (; !needSyncCheck && !this.stopMainThread;) {
+                    let header = this.liveHeaders.shift();
+                    if (header) {
+                        // Process a "live" block header...
+                        let recursions = this.addLiveRecursionLimit;
+                        for (; !needSyncCheck && !this.stopMainThread;) {
+                            //console.log(`Processing liveHeader: height: ${header.height} hash: ${header.hash} ${new Date().toISOString()}`)
+                            const ihr = await this.addLiveHeader(header);
+                            if (this.invalidInsertHeaderResult(ihr)) {
+                                this.log(`Ignoring liveHeader ${header.height} ${header.hash} due to invalid insert result.`);
+                                needSyncCheck = true;
+                            }
+                            else if (ihr.noPrev) {
+                                // Previous header is unknown, request it by hash from the network and try adding it first...
+                                if (recursions-- <= 0) {
+                                    // Ignore this header...
+                                    this.log(`Ignoring liveHeader ${header.height} ${header.hash} addLiveRecursionLimit=${this.addLiveRecursionLimit} exceeded.`);
+                                    needSyncCheck = true;
+                                }
+                                else {
+                                    const hash = header.previousHash;
+                                    const prevHeader = await this.getMissingBlockHeader(hash);
+                                    if (!prevHeader) {
+                                        this.log(`Ignoring liveHeader ${header.height} ${header.hash} failed to find previous header by hash ${(0, utilityHelpers_noBuffer_1.asString)(hash)}`);
+                                        needSyncCheck = true;
+                                    }
+                                    else {
+                                        // Switch to trying to add prevHeader, unshifting current header to try it again after prevHeader exists.
+                                        this.liveHeaders.unshift(header);
+                                        header = prevHeader;
+                                    }
+                                }
+                            }
+                            else {
+                                if (this.subscriberCallbacksEnabled)
+                                    this.log(`addLiveHeader ${header.height}${ihr.added ? ' added' : ''}${ihr.dupe ? ' dupe' : ''}${ihr.isActiveTip ? ' isActiveTip' : ''}${ihr.reorgDepth ? ' reorg depth ' + ihr.reorgDepth : ''}${ihr.noPrev ? ' noPrev' : ''}${ihr.noActiveAncestor || ihr.noTip || ihr.badPrev ? ' error' : ''}`);
+                                if (ihr.dupe) {
+                                    liveHeaderDupes++;
+                                }
+                                // Header wasn't invalid and previous header is known. If it was successfully added, count it as a win.
+                                if (ihr.added) {
+                                    count++;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        // There are no liveHeaders currently to process, check the out-of-band baseHeaders channel (`addHeader` method called by a client).
+                        const bheader = this.baseHeaders.shift();
+                        if (bheader) {
+                            const prev = await this.storage.findLiveHeaderForBlockHash(bheader.previousHash);
+                            if (!prev) {
+                                // Ignoring attempt to add a baseHeader with unknown previous hash, no attempt made to find previous header(s).
+                                this.log(`Ignoring header with unknown previousHash ${bheader.previousHash} in live storage.`);
+                                // Does not trigger a re-sync.
+                            }
+                            else {
+                                const header = {
+                                    ...bheader,
+                                    height: prev.height + 1,
+                                    hash: (0, blockHeaderUtilities_1.blockHash)(bheader)
+                                };
+                                const ihr = await this.addLiveHeader(header);
+                                if (this.invalidInsertHeaderResult(ihr)) {
+                                    this.log(`Ignoring invalid baseHeader ${header.height} ${header.hash}.`);
+                                }
+                                else {
+                                    if (this.subscriberCallbacksEnabled)
+                                        this.log(`addBaseHeader ${header.height}${ihr.added ? ' added' : ''}${ihr.dupe ? ' dupe' : ''}${ihr.isActiveTip ? ' isActiveTip' : ''}${ihr.reorgDepth ? ' reorg depth ' + ihr.reorgDepth : ''}${ihr.noPrev ? ' noPrev' : ''}${ihr.noActiveAncestor || ihr.noTip || ihr.badPrev ? ' error' : ''}`);
+                                    // baseHeader was successfully added.
+                                    if (ihr.added) {
+                                        count++;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            // There are no liveHeaders and no baseHeaders to add,
+                            if (count > 0) {
+                                if (liveHeaderDupes > 0) {
+                                    this.log(`${liveHeaderDupes} duplicate headers ignored.`);
+                                    liveHeaderDupes = 0;
+                                }
+                                const updated = await this.storage.getAvailableHeightRanges();
+                                this.log(`After adding ${count} live headers
+   After live: bulk ${updated.bulk}, live ${updated.live}
+`);
+                                count = 0;
+                            }
+                            if (!this.subscriberCallbacksEnabled) {
+                                const live = await this.storage.findLiveHeightRange();
+                                if (!live.isEmpty) {
+                                    this.subscriberCallbacksEnabled = true;
+                                    this.log(`listening at height of ${live.maxHeight}`);
+                                }
+                            }
+                            if (!this.available) {
+                                this.available = true;
+                            }
+                            needSyncCheck = Date.now() - lastSyncCheck > syncCheckRepeatMsecs;
+                            // If we aren't going to review sync, wait before checking input queues again
+                            if (!needSyncCheck)
+                                await (0, utilityHelpers_1.wait)(1000);
+                        }
+                    }
+                }
+            }
+            catch (eu) {
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                if (!this.available) {
+                    this.startupError = e;
+                    this.stopMainThread = true;
+                }
+                else {
+                    this.log(`Error occurred during chaintracks main thread processing: ${e.stack || e.message}`);
+                }
+            }
+        }
+    }
+}
+exports.Chaintracks = Chaintracks;
+//# sourceMappingURL=Chaintracks.js.map