@bsv/wallet-toolbox-client 2.8.0 → 2.9.0

package/out/index.client.cjs

@@ -19597,6 +19597,24 @@ function isLiveBlockHeader(header) {
 	return "chainWork" in header && typeof header.previousHash === "string";
 }
 //#endregion
+//#region ../src/services/chaintracker/chaintracks/Api/BulkFileDataValidatorApi.ts
+/**
+* Identifies deterministic rejection of the supplied immutable bytes.
+* Operational failures such as worker crashes and queue saturation deliberately
+* use ordinary errors so callers preserve the cache entry and avoid downloading
+* a replacement that cannot be validated.
+*
+* @public
+*/
+var BulkFileDataValidationError = class extends Error {
+	data;
+	constructor(message, data) {
+		super(message);
+		this.data = data;
+		this.name = "BulkFileDataValidationError";
+	}
+};
+//#endregion
 //#region ../src/services/chaintracker/chaintracks/util/HeightRange.ts
 /**
 * Represents a range of block heights.
@@ -19815,6 +19833,8 @@ var Chaintracks = class {
 	lastPresentHeight = -1;
 	lastPresentHeightMsecs = 0;
 	lastPresentHeightMaxAge = 60 * 1e3;
+	presentHeightRefresh;
+	mainLoopHeartbeatMsecs = 0;
 	lock = new SingleWriterMultiReaderLock();
 	sourceStatus = /* @__PURE__ */ new Map();
 	constructor(options) {
@@ -19852,12 +19872,31 @@ var Chaintracks = class {
 		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).
+	* Returns the last known valid height immediately and refreshes stale state
+	* once in the background. Cold start waits for the single shared refresh.
 	*/
 	async getPresentHeight() {
 		const now = Date.now();
 		if (this.lastPresentHeight >= 0 && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) return this.lastPresentHeight;
+		if (this.lastPresentHeight >= 0) {
+			this.refreshPresentHeight().catch((error) => {
+				this.log(`Background present-height refresh failed: ${WalletError.fromUnknown(error).message}`);
+			});
+			return this.lastPresentHeight;
+		}
+		return await this.refreshPresentHeight();
+	}
+	async refreshPresentHeight() {
+		if (this.presentHeightRefresh != null) return await this.presentHeightRefresh;
+		const refresh = this.loadPresentHeight();
+		this.presentHeightRefresh = refresh;
+		try {
+			return await refresh;
+		} finally {
+			if (this.presentHeightRefresh === refresh) this.presentHeightRefresh = void 0;
+		}
+	}
+	async loadPresentHeight() {
 		for (const [index, bulk] of this.bulkIngestors.entries()) {
 			const source = this.sourceName("bulk", index, bulk);
 			try {
@@ -19865,7 +19904,7 @@ var Chaintracks = class {
 				if (presentHeight != null && Number.isInteger(presentHeight) && presentHeight >= 0) {
 					this.markSourceSuccess(source, "bulk");
 					this.lastPresentHeight = presentHeight;
-					this.lastPresentHeightMsecs = now;
+					this.lastPresentHeightMsecs = Date.now();
 					return presentHeight;
 				}
 			} catch (uerr) {
@@ -19880,7 +19919,7 @@ var Chaintracks = class {
 			const localHeight = Math.max(ranges.bulk.maxHeight, ranges.live.maxHeight);
 			if (localHeight >= 0) {
 				this.lastPresentHeight = localHeight;
-				this.lastPresentHeightMsecs = now;
+				this.lastPresentHeightMsecs = Date.now();
 				return localHeight;
 			}
 		} catch (error) {
@@ -19891,6 +19930,19 @@ var Chaintracks = class {
 	async currentHeight() {
 		return await this.getPresentHeight();
 	}
+	/** Returns local process state without locks, storage reads, or network I/O. */
+	getAvailabilitySnapshot() {
+		return {
+			available: this.available,
+			startupError: this.startupError?.message,
+			presentHeight: this.lastPresentHeight >= 0 ? this.lastPresentHeight : void 0,
+			presentHeightUpdatedAt: this.lastPresentHeightMsecs > 0 ? new Date(this.lastPresentHeightMsecs).toISOString() : void 0,
+			presentHeightRefreshInFlight: this.presentHeightRefresh != null,
+			mainLoopHeartbeatAt: this.mainLoopHeartbeatMsecs > 0 ? new Date(this.mainLoopHeartbeatMsecs).toISOString() : void 0,
+			sources: Array.from(this.sourceStatus.values()).map((status) => ({ ...status })),
+			bulkData: this.storage.bulkManager.getStats()
+		};
+	}
 	async subscribeHeaders(listener) {
 		const ID = randomBytesBase64(8);
 		this.callbacks.header[ID] = listener;
@@ -19955,6 +20007,7 @@ var Chaintracks = class {
 			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.bulkManager.destroy();
 			await this.storage.destroy();
 			this.available = false;
 			this.stopMainThread = false;
@@ -20236,9 +20289,11 @@ var Chaintracks = class {
 		const syncCheckRepeatMsecs = 1800 * 1e3;
 		while (!this.stopMainThread) try {
 			const now = Date.now();
+			this.mainLoopHeartbeatMsecs = now;
 			lastSyncCheck = now;
 			lastBulkSync = await this.runBulkSyncIfNeeded(now, lastBulkSync, cdnSyncRepeatMsecs);
 			await this.processLiveHeaderQueue(lastSyncCheck, syncCheckRepeatMsecs);
+			this.mainLoopHeartbeatMsecs = Date.now();
 		} catch (error_) {
 			const e = WalletError.fromUnknown(error_);
 			if (this.available) this.log(`Error occurred during chaintracks main thread processing: ${e.stack || e.message}`);
@@ -20250,7 +20305,7 @@ var Chaintracks = class {
 	}
 	/** Returns (potentially updated) lastBulkSync timestamp. */
 	async runBulkSyncIfNeeded(now, lastBulkSync, cdnSyncRepeatMsecs) {
-		const presentHeight = await this.getPresentHeight();
+		const presentHeight = await this.refreshPresentHeight();
 		const before = await this.storage.getAvailableHeightRanges();
 		let skipBulkSync = !before.live.isEmpty && before.live.maxHeight >= presentHeight - this.addLiveRecursionLimit / 2;
 		if (skipBulkSync && now - lastBulkSync > cdnSyncRepeatMsecs) skipBulkSync = false;
@@ -21399,12 +21454,12 @@ var ChaintracksFetch = class {
 		this.maxRetryMsecs = positiveSafeInteger(options.maxRetryMsecs, DEFAULT_MAX_RETRY_MSECS, "maxRetryMsecs");
 		this.random = options.random ?? Math.random;
 	}
-	async download(url, maxResponseBytes) {
+	async download(url, maxResponseBytes, options) {
 		const responseLimit = maxResponseBytes == null ? this.maxResponseBytes : Math.min(this.maxResponseBytes, positiveSafeInteger(maxResponseBytes, this.maxResponseBytes, "maxResponseBytes"));
 		return await this.requestBytes(url, {
 			method: "GET",
 			headers: { Accept: "application/octet-stream" }
-		}, "download", responseLimit);
+		}, "download", responseLimit, options);
 	}
 	async fetchJson(url) {
 		const bytes = await this.requestBytes(url, {
@@ -21413,8 +21468,9 @@ var ChaintracksFetch = class {
 		}, "fetch JSON", this.maxResponseBytes);
 		return JSON.parse(new TextDecoder().decode(bytes));
 	}
-	async requestBytes(url, init, kind, maxResponseBytes) {
+	async requestBytes(url, init, kind, maxResponseBytes, downloadOptions) {
 		for (let retry = 0;; retry++) {
+			if (retry > 0) await downloadOptions?.beforeRetry?.(retry + 1);
 			const controller = new AbortController();
 			const timeout = setTimeout(() => controller.abort(), this.timeoutMsecs);
 			try {
@@ -21490,6 +21546,38 @@ var ChaintracksFetch = class {
 	}
 };
 //#endregion
+//#region ../src/services/chaintracker/chaintracks/util/InlineBulkFileDataValidator.ts
+/**
+* Portable complete-object validator. Node services should normally inject
+* `NodeBulkFileDataValidator`; browser and mobile consumers retain this
+* dependency-free fallback.
+*
+* @public
+*/
+var InlineBulkFileDataValidator = class {
+	async validate(request) {
+		try {
+			const expectedLength = request.count * 80;
+			if (request.data.length !== expectedLength) throw new WERR_INVALID_PARAMETER("file.data", `bulk file ${request.fileName} data length ${request.data.length} does not match expected count ${request.count}`);
+			const fileHash = asString(_bsv_sdk.Hash.sha256(asArray(request.data)), "base64");
+			if (request.fileHash != null && fileHash !== request.fileHash) throw new WERR_INVALID_PARAMETER("fileHash", `a match for retrieved data for ${request.fileName}`);
+			const { lastHeaderHash, lastChainWork } = validateBufferOfHeaders(request.data, request.prevHash, 0, request.count, request.prevChainWork);
+			if (request.lastHash && request.lastHash !== lastHeaderHash) throw new WERR_INVALID_PARAMETER("file.lastHash", `expected ${request.lastHash} but got ${lastHeaderHash}`);
+			if (request.lastChainWork && request.lastChainWork !== lastChainWork) throw new WERR_INVALID_PARAMETER("file.lastChainWork", `expected ${request.lastChainWork} but got ${lastChainWork}`);
+			if (request.firstHeight === 0 && request.chain != null) validateGenesisHeader(request.data, request.chain);
+			return {
+				data: request.data,
+				fileHash,
+				lastHeaderHash,
+				lastChainWork
+			};
+		} catch (error) {
+			if (error instanceof BulkFileDataValidationError) throw error;
+			throw new BulkFileDataValidationError(error instanceof Error ? error.message : String(error), request.data);
+		}
+	}
+};
+//#endregion
 //#region ../src/services/chaintracker/chaintracks/util/BulkFileDataManager.ts
 /**
 * Manages bulk file data (typically 8MB chunks of 100,000 headers each).
@@ -21515,6 +21603,7 @@ var BulkFileDataManager = class BulkFileDataManager {
 	fileHashToIndex = {};
 	lock = new SingleWriterMultiReaderLock();
 	inFlightLoads = /* @__PURE__ */ new Map();
+	failedLoads = /* @__PURE__ */ new Map();
 	storage;
 	stats = {
 		memoryHits: 0,
@@ -21524,7 +21613,8 @@ var BulkFileDataManager = class BulkFileDataManager {
 		persistentCacheRejects: 0,
 		coalescedLoads: 0,
 		downloads: 0,
-		downloadedBytes: 0
+		downloadedBytes: 0,
+		loadBackoffs: 0
 	};
 	chain;
 	maxPerFile;
@@ -21533,6 +21623,8 @@ var BulkFileDataManager = class BulkFileDataManager {
 	fromKnownSourceUrl;
 	cache;
 	downloadBudget;
+	validator;
+	failedLoadRetryMsecs;
 	constructor(options) {
 		const resolvedOptions = typeof options === "object" ? options : BulkFileDataManager.createDefaultOptions(options);
 		this.chain = resolvedOptions.chain;
@@ -21542,10 +21634,17 @@ var BulkFileDataManager = class BulkFileDataManager {
 		this.fetch = resolvedOptions.fetch;
 		this.cache = resolvedOptions.cache;
 		this.downloadBudget = resolvedOptions.downloadBudget;
+		this.validator = resolvedOptions.validator ?? new InlineBulkFileDataValidator();
+		this.failedLoadRetryMsecs = resolvedOptions.failedLoadRetryMsecs ?? 30 * 1e3;
+		if (!Number.isSafeInteger(this.failedLoadRetryMsecs) || this.failedLoadRetryMsecs < 0) throw new WERR_INVALID_PARAMETER("failedLoadRetryMsecs", "a non-negative safe integer");
 		this.deleteBulkFilesNoLock();
 	}
 	getStats() {
-		return { ...this.stats };
+		return {
+			...this.stats,
+			validation: this.validator.getStats?.(),
+			downloadBudget: this.downloadBudget?.snapshot?.()
+		};
 	}
 	async deleteBulkFiles() {
 		return await this.lock.withWriteLock(async () => this.deleteBulkFilesNoLock());
@@ -21764,9 +21863,29 @@ var BulkFileDataManager = class BulkFileDataManager {
 		});
 	}
 	async getDataFromFile(file, offset, length) {
-		const bfd = this.getBfdForHeight(file.firstHeight);
-		if (bfd == null || bfd.count < file.count) throw new WERR_INVALID_PARAMETER("file", `a match for ${file.firstHeight}, ${file.count} in the BulkFileDataManager.`);
-		return await this.lock.withReadLock(async () => await this.getDataFromFileNoLock(bfd, offset, length));
+		const resolved = await this.lock.withReadLock(async () => {
+			const resolved = this.getBfdForHeight(file.firstHeight);
+			if (resolved == null || resolved.count < file.count) throw new WERR_INVALID_PARAMETER("file", `a match for ${file.firstHeight}, ${file.count} in the BulkFileDataManager.`);
+			return {
+				current: resolved,
+				snapshot: snapshotBfd(resolved)
+			};
+		});
+		return await this.getDataFromSnapshot(resolved.current, resolved.snapshot, offset, length);
+	}
+	async getDataFromSnapshot(original, snapshot, offset, length) {
+		const data = await this.getDataFromFileNoLock(snapshot, offset, length);
+		if (snapshot.data != null) await this.lock.withWriteLock(async () => {
+			if (this.bfds.includes(original) && original.fileHash === snapshot.fileHash && original.firstHeight === snapshot.firstHeight && original.count === snapshot.count) {
+				original.data = snapshot.data;
+				original.validated = true;
+				original.lastHash = snapshot.lastHash;
+				original.lastChainWork = snapshot.lastChainWork;
+				original.mru = Date.now();
+				this.ensureMaxRetained();
+			}
+		});
+		return data;
 	}
 	async getDataFromFileNoLock(bfd, offset, length) {
 		const fileLength = bfd.count * 80;
@@ -21777,15 +21896,19 @@ var BulkFileDataManager = class BulkFileDataManager {
 		return (await this.ensureData(bfd)).slice(offset, offset + length);
 	}
 	async findHeaderForHeightOrUndefined(height) {
-		return await this.lock.withReadLock(async () => {
+		const resolved = await this.lock.withReadLock(async () => {
 			if (!Number.isInteger(height) || height < 0) throw new WERR_INVALID_PARAMETER("height", `a non-negative integer (${height}).`);
 			const file = this.bfds.find((f) => f.firstHeight <= height && f.firstHeight + f.count > height);
 			if (file == null) return void 0;
-			const offset = (height - file.firstHeight) * 80;
-			const data = await this.getDataFromFileNoLock(file, offset, 80);
-			if (data == null) return void 0;
-			return deserializeBlockHeader(data, height, 0);
+			return {
+				current: file,
+				snapshot: snapshotBfd(file),
+				offset: (height - file.firstHeight) * 80
+			};
 		});
+		if (resolved == null) return void 0;
+		const data = await this.getDataFromSnapshot(resolved.current, resolved.snapshot, resolved.offset, 80);
+		return data == null ? void 0 : deserializeBlockHeader(data, height, 0);
 	}
 	async getFileForHeight(height) {
 		return await this.lock.withReadLock(async () => {
@@ -21840,22 +21963,30 @@ var BulkFileDataManager = class BulkFileDataManager {
 		return bfd;
 	}
 	async validateBfdData(bfd, expectedFileHash) {
-		await this.ensureData(bfd);
-		if (bfd.data?.length !== bfd.count * 80) throw new WERR_INVALID_PARAMETER("file.data", `bulk file ${bfd.fileName} data length ${bfd.data?.length} does not match expected count ${bfd.count}`);
-		bfd.fileHash = asString(_bsv_sdk.Hash.sha256(asArray(bfd.data)), "base64");
-		if (expectedFileHash && expectedFileHash !== bfd.fileHash) throw new WERR_INVALID_PARAMETER("file.fileHash", `expected ${expectedFileHash} but got ${bfd.fileHash}`);
-		this.validateBfdHeaders(bfd);
+		const data = await this.ensureData(bfd);
+		bfd.data = await this.validateRetrievedData(bfd, data, expectedFileHash);
 	}
-	validateBfdHeaders(bfd) {
+	async validateBfdHeaders(bfd, expectedFileHash = bfd.fileHash) {
 		const pbf = bfd.firstHeight > 0 ? this.getBfdForHeight(bfd.firstHeight - 1) : void 0;
 		const prevHash = pbf?.lastHash ?? "00".repeat(32);
 		const prevChainWork = pbf?.lastChainWork ?? "00".repeat(32);
-		const { lastHeaderHash, lastChainWork } = validateBufferOfHeaders(bfd.data, prevHash, 0, void 0, prevChainWork);
-		if (bfd.lastHash && bfd.lastHash !== lastHeaderHash) throw new WERR_INVALID_PARAMETER("file.lastHash", `expected ${bfd.lastHash} but got ${lastHeaderHash}`);
-		if (bfd.lastChainWork && bfd.lastChainWork !== lastChainWork) throw new WERR_INVALID_PARAMETER("file.lastChainWork", `expected ${bfd.lastChainWork} but got ${lastChainWork}`);
-		bfd.lastHash = lastHeaderHash;
-		bfd.lastChainWork = lastChainWork;
-		if (bfd.firstHeight === 0) validateGenesisHeader(bfd.data, bfd.chain);
+		const result = await this.validator.validate({
+			fileName: bfd.fileName,
+			data: bfd.data,
+			count: bfd.count,
+			fileHash: expectedFileHash,
+			firstHeight: bfd.firstHeight,
+			prevHash,
+			prevChainWork,
+			lastHash: bfd.lastHash,
+			lastChainWork: bfd.lastChainWork,
+			chain: bfd.chain
+		});
+		bfd.data = result.data;
+		bfd.fileHash = result.fileHash;
+		bfd.lastHash = result.lastHeaderHash;
+		bfd.lastChainWork = result.lastChainWork;
+		return result.data;
 	}
 	async ReValidate() {
 		return await this.lock.withReadLock(async () => await this.ReValidateNoLock());
@@ -22046,62 +22177,96 @@ var BulkFileDataManager = class BulkFileDataManager {
 			this.ensureMaxRetained();
 			return data;
 		}
+		const failed = this.failedLoads.get(key);
+		if (failed != null) {
+			if (Date.now() < failed.retryAt) {
+				this.stats.loadBackoffs++;
+				throw failed.error;
+			}
+			this.failedLoads.delete(key);
+		}
 		const load = this.loadAndValidateData(bfd);
 		this.inFlightLoads.set(key, load);
 		try {
 			const data = await load;
 			bfd.data = data;
 			bfd.validated = true;
+			this.failedLoads.delete(key);
 			bfd.mru = Date.now();
 			this.ensureMaxRetained();
 			return data;
+		} catch (error) {
+			const resolved = error instanceof Error ? error : new Error(String(error));
+			this.failedLoads.set(key, {
+				retryAt: Date.now() + this.failedLoadRetryMsecs,
+				error: resolved
+			});
+			throw resolved;
 		} finally {
 			if (this.inFlightLoads.get(key) === load) this.inFlightLoads.delete(key);
 		}
 	}
 	async loadAndValidateData(bfd) {
-		if (this.storage != null && bfd.fileId) {
-			const stored = await this.storage.getBulkFileData(bfd.fileId);
-			if (stored == null) throw new WERR_INVALID_PARAMETER("fileId", `valid, data not found for fileId ${bfd.fileId}`);
-			this.validateRetrievedData(bfd, stored);
-			this.stats.storageHits++;
-			return stored;
-		}
-		if (this.cache != null) {
-			const cached = await this.cache.get(bfd);
-			if (cached != null) try {
-				this.validateRetrievedData(bfd, cached);
-				this.stats.persistentCacheHits++;
-				return cached;
-			} catch (error) {
-				this.stats.persistentCacheRejects++;
-				await this.cache.delete?.(bfd);
-				this.log(`Rejected corrupt bulk-header cache entry ${bfd.fileName}: ${String(error)}`);
-			}
-			else this.stats.persistentCacheMisses++;
-		}
-		if (this.fetch != null && bfd.sourceUrl) {
-			const expectedBytes = bfd.count * 80;
-			await this.downloadBudget?.consume(expectedBytes);
-			const url = this.fetch.pathJoin(bfd.sourceUrl, bfd.fileName);
-			const downloaded = await this.fetch.download(url, expectedBytes);
-			if (downloaded == null) throw new WERR_INVALID_PARAMETER("sourceUrl", `data not found for sourceUrl ${url}`);
-			this.validateRetrievedData(bfd, downloaded);
-			this.stats.downloads++;
-			this.stats.downloadedBytes += downloaded.length;
-			await this.cache?.set(bfd, downloaded);
-			return downloaded;
-		}
+		const stored = await this.loadFromStorage(bfd);
+		if (stored != null) return stored;
+		const cached = await this.loadFromCache(bfd);
+		if (cached != null) return cached;
+		const downloaded = await this.loadFromRemote(bfd);
+		if (downloaded != null) return downloaded;
 		throw new WERR_INVALID_PARAMETER("data", `defined. Unable to retrieve data for ${bfd.fileName}`);
 	}
-	validateRetrievedData(bfd, data) {
-		if (data.length !== bfd.count * 80) throw new WERR_INVALID_PARAMETER("file.data", `bulk file ${bfd.fileName} data length ${data.length} does not match expected count ${bfd.count}`);
-		if (asString(_bsv_sdk.Hash.sha256(asArray(data)), "base64") !== bfd.fileHash) throw new WERR_INVALID_PARAMETER("fileHash", `a match for retrieved data for ${bfd.fileName}`);
+	async loadFromStorage(bfd) {
+		if (this.storage == null || !bfd.fileId) return void 0;
+		const stored = await this.storage.getBulkFileData(bfd.fileId);
+		if (stored == null) throw new WERR_INVALID_PARAMETER("fileId", `valid, data not found for fileId ${bfd.fileId}`);
+		const validated = await this.validateRetrievedData(bfd, stored);
+		this.stats.storageHits++;
+		return validated;
+	}
+	async loadFromCache(bfd) {
+		if (this.cache == null) return void 0;
+		const cached = await this.cache.get(bfd);
+		if (cached == null) {
+			this.stats.persistentCacheMisses++;
+			return;
+		}
+		try {
+			const validated = await this.validateRetrievedData(bfd, cached);
+			this.stats.persistentCacheHits++;
+			await this.cache.promoteValidated?.(bfd, validated);
+			return validated;
+		} catch (error) {
+			if (!(error instanceof BulkFileDataValidationError)) throw error;
+			this.stats.persistentCacheRejects++;
+			let rejectedData = error.data;
+			if (!(rejectedData instanceof Uint8Array) && cached.byteLength > 0) rejectedData = cached;
+			await this.cache.quarantine?.(bfd, String(error), rejectedData);
+			this.log(`Rejected corrupt bulk-header cache entry ${bfd.fileName}: ${String(error)}`);
+			return;
+		}
+	}
+	async loadFromRemote(bfd) {
+		if (this.fetch == null || !bfd.sourceUrl) return void 0;
+		const expectedBytes = bfd.count * 80;
+		await this.downloadBudget?.consume(expectedBytes);
+		const url = this.fetch.pathJoin(bfd.sourceUrl, bfd.fileName);
+		const downloaded = await this.fetch.download(url, expectedBytes, { beforeRetry: async () => await this.downloadBudget?.consume(expectedBytes) });
+		if (downloaded == null) throw new WERR_INVALID_PARAMETER("sourceUrl", `data not found for sourceUrl ${url}`);
+		const validated = await this.validateRetrievedData(bfd, downloaded);
+		this.stats.downloads++;
+		this.stats.downloadedBytes += validated.length;
+		await this.cache?.set(bfd, validated);
+		return validated;
+	}
+	async validateRetrievedData(bfd, data, expectedFileHash = bfd.fileHash) {
 		const candidate = {
 			...bfd,
 			data
 		};
-		this.validateBfdHeaders(candidate);
+		const validated = await this.validateBfdHeaders(candidate, expectedFileHash);
+		bfd.lastHash = candidate.lastHash;
+		bfd.lastChainWork = candidate.lastChainWork;
+		return validated;
 	}
 	ensureMaxRetained() {
 		if (this.maxRetained === void 0) return;
@@ -22137,17 +22302,24 @@ var BulkFileDataManager = class BulkFileDataManager {
 			i++;
 			const data = await reader.read();
 			if (data == null || data.length === 0) break;
-			const last = validateBufferOfHeaders(data, lastHeaderHash, 0, void 0, lastChainWork);
-			await toFs.writeFile(toPath(i), data);
-			const fileHash = asString(_bsv_sdk.Hash.sha256(asArray(data)), "base64");
+			const validated = await this.validator.validate({
+				fileName: toFileName(i),
+				data,
+				count: data.length / 80,
+				firstHeight,
+				prevHash: lastHeaderHash,
+				prevChainWork: lastChainWork,
+				chain
+			});
+			await toFs.writeFile(toPath(i), validated.data);
 			const file = {
 				chain,
-				count: data.length / 80,
-				fileHash,
+				count: validated.data.length / 80,
+				fileHash: validated.fileHash,
 				fileName: toFileName(i),
 				firstHeight,
-				lastChainWork: last.lastChainWork,
-				lastHash: last.lastHeaderHash,
+				lastChainWork: validated.lastChainWork,
+				lastHash: validated.lastHeaderHash,
 				prevChainWork: lastChainWork,
 				prevHash: lastHeaderHash,
 				sourceUrl
@@ -22159,7 +22331,16 @@ var BulkFileDataManager = class BulkFileDataManager {
 		}
 		await toFs.writeFile(toJsonPath(), asUint8Array(JSON.stringify(toBulkFiles), "utf8"));
 	}
+	async destroy() {
+		await this.validator.destroy?.();
+	}
 };
+function snapshotBfd(file) {
+	return {
+		...file,
+		data: file.data
+	};
+}
 function selectBulkHeaderFiles(files, chain, maxPerFile) {
 	const r = [];
 	let height = 0;
@@ -27028,7 +27209,8 @@ function createDefaultBulkFileDataManager(params) {
 		maxRetained: params.maxRetained,
 		fromKnownSourceUrl: params.cdnUrl,
 		cache: params.sources.bulkFileCache,
-		downloadBudget: params.sources.bulkFileDownloadBudget
+		downloadBudget: params.sources.bulkFileDownloadBudget,
+		validator: params.sources.bulkFileDataValidator
 	});
 }
 function createDefaultChaintracksStorageOptions(params) {
@@ -27553,6 +27735,7 @@ var FixedWindowBulkFileDownloadBudget = class {
 		return {
 			maxBytes: this.maxBytes,
 			consumedBytes: this.consumedBytes,
+			remainingBytes: this.maxBytes - this.consumedBytes,
 			windowStartedAt: this.windowStartedAt,
 			windowMsecs: this.windowMsecs
 		};
@@ -36828,6 +37011,7 @@ exports.BHServiceClient = BHServiceClient;
 exports.BRC153_REFERENCE_PREFIX = BRC153_REFERENCE_PREFIX;
 exports.BulkFileDataManager = BulkFileDataManager;
 exports.BulkFileDataReader = BulkFileDataReader;
+exports.BulkFileDataValidationError = BulkFileDataValidationError;
 exports.BulkFilesReader = BulkFilesReader;
 exports.BulkFilesReaderFs = BulkFilesReaderFs;
 exports.BulkFilesReaderStorage = BulkFilesReaderStorage;
@@ -36876,6 +37060,7 @@ exports.EntityUser = EntityUser;
 exports.FixedWindowBulkFileDownloadBudget = FixedWindowBulkFileDownloadBudget;
 exports.GoChaintracksServiceClient = GoChaintracksServiceClient;
 exports.HeightRange = HeightRange;
+exports.InlineBulkFileDataValidator = InlineBulkFileDataValidator;
 exports.KDF_MAX_HASH_LENGTH = KDF_MAX_HASH_LENGTH;
 exports.LEGACY_MANAGED_CHANGE_MINIMUM_SATOSHIS = LEGACY_MANAGED_CHANGE_MINIMUM_SATOSHIS;
 exports.LiveIngestorBase = LiveIngestorBase;