@cogcoin/client 0.5.4 → 0.5.6

package/dist/bitcoind/bootstrap/download.js

@@ -1,7 +1,10 @@
+import { createHash } from "node:crypto";
 import { mkdir, open, rename, rm } from "node:fs/promises";
 import { formatManagedSyncErrorMessage } from "../errors.js";
-import { DEFAULT_SNAPSHOT_METADATA, DOWNLOAD_RETRY_BASE_MS, DOWNLOAD_RETRY_MAX_MS, } from "./constants.js";
-import { resetSnapshotFiles, statOrNull, validateSnapshotFileForTesting } from "./snapshot-file.js";
+import { DOWNLOAD_RETRY_BASE_MS, DOWNLOAD_RETRY_MAX_MS, } from "./constants.js";
+import { applyVerifiedFrontierState, reconcileSnapshotDownloadArtifacts, } from "./chunk-recovery.js";
+import { resolveBundledSnapshotChunkManifest, resolveSnapshotChunkCount, resolveSnapshotChunkSize, resolveVerifiedChunkBytes, } from "./chunk-manifest.js";
+import { statOrNull, validateSnapshotFileForTesting } from "./snapshot-file.js";
 import { saveBootstrapState } from "./state.js";
 function describeSnapshotDownloadError(error, url) {
     if (!(error instanceof Error)) {
@@ -27,14 +30,48 @@ function describeSnapshotDownloadError(error, url) {
         ? `snapshot download failed from ${source}: ${causeMessage}`
         : `snapshot download failed from ${source}: fetch failed`;
 }
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
+function createAbortError(signal) {
+    const reason = signal?.reason;
+    if (reason instanceof Error) {
+        return reason;
+    }
+    const error = new Error("managed_sync_aborted");
+    error.name = "AbortError";
+    return error;
+}
+function isAbortError(error, signal) {
+    if (signal?.aborted) {
+        return true;
+    }
+    return error instanceof Error
+        && (error.name === "AbortError" || error.message === "managed_sync_aborted");
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal);
+    }
+}
+function sleep(ms, signal) {
+    if (ms <= 0) {
+        throwIfAborted(signal);
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject(createAbortError(signal));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-function updateDownloadProgress(progress, state, downloadedBytes, resumed, startedAt) {
+function updateDownloadProgress(progress, state, attemptStartBytes, downloadedBytes, resumed, startedAt) {
     const elapsedSeconds = Math.max(0.001, (Date.now() - startedAt) / 1000);
-    const bytesPerSecond = Math.max(0, (downloadedBytes - state.downloadedBytes) / elapsedSeconds);
+    const bytesPerSecond = Math.max(0, (downloadedBytes - attemptStartBytes) / elapsedSeconds);
     const remaining = Math.max(0, state.snapshot.sizeBytes - downloadedBytes);
     return progress.setPhase("snapshot_download", {
         message: "Downloading UTXO snapshot.",
@@ -48,76 +85,112 @@ function updateDownloadProgress(progress, state, downloadedBytes, resumed, start
         lastError: state.lastError,
     });
 }
+async function persistVerifiedChunk(state, manifest, verifiedChunkCount, options) {
+    applyVerifiedFrontierState(state, manifest, verifiedChunkCount);
+    state.validated = false;
+    state.lastError = null;
+    await saveBootstrapState(options.paths, state);
+}
+async function finalizeSnapshotDownload(metadata, manifest, state, options, resumed) {
+    await validateSnapshotFileForTesting(options.paths.partialSnapshotPath, metadata);
+    await rename(options.paths.partialSnapshotPath, options.paths.snapshotPath);
+    applyVerifiedFrontierState(state, manifest, resolveSnapshotChunkCount(manifest));
+    state.validated = true;
+    state.lastError = null;
+    await saveBootstrapState(options.paths, state);
+    await options.progress.setPhase("snapshot_download", {
+        resumed,
+        downloadedBytes: metadata.sizeBytes,
+        totalBytes: metadata.sizeBytes,
+        percent: 100,
+        bytesPerSecond: null,
+        etaSeconds: 0,
+        lastError: null,
+    });
+}
+async function finalizeExistingSnapshot(metadata, manifest, state, options) {
+    applyVerifiedFrontierState(state, manifest, resolveSnapshotChunkCount(manifest));
+    state.validated = true;
+    state.lastError = null;
+    await saveBootstrapState(options.paths, state);
+    await rm(options.paths.partialSnapshotPath, { force: true });
+    await options.progress.setPhase("snapshot_download", {
+        resumed: false,
+        downloadedBytes: metadata.sizeBytes,
+        totalBytes: metadata.sizeBytes,
+        percent: 100,
+        bytesPerSecond: null,
+        etaSeconds: 0,
+        lastError: null,
+    });
+}
+async function truncateToVerifiedFrontier(path, verifiedBytes) {
+    const file = await open(path, "a+");
+    try {
+        await file.truncate(verifiedBytes);
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+}
 export async function downloadSnapshotFileForTesting(options) {
-    const { metadata, paths, progress, fetchImpl = fetch } = options;
+    const { metadata, paths, progress, fetchImpl = fetch, signal, snapshotIdentity = "current", } = options;
+    const manifest = options.manifest ?? resolveBundledSnapshotChunkManifest(metadata);
     const state = options.state;
     await mkdir(paths.directory, { recursive: true });
-    const existingPart = await statOrNull(paths.partialSnapshotPath);
     const existingFull = await statOrNull(paths.snapshotPath);
     if (state.validated && existingFull?.size === metadata.sizeBytes) {
-        await progress.setPhase("snapshot_download", {
-            resumed: false,
-            downloadedBytes: metadata.sizeBytes,
-            totalBytes: metadata.sizeBytes,
-            percent: 100,
-            bytesPerSecond: null,
-            etaSeconds: 0,
-            lastError: null,
-        });
+        await finalizeExistingSnapshot(metadata, manifest, state, { paths, progress });
         return;
     }
-    if (!state.validated && existingFull?.size === metadata.sizeBytes) {
+    if (existingFull?.size === metadata.sizeBytes) {
         try {
             await validateSnapshotFileForTesting(paths.snapshotPath, metadata);
-            state.validated = true;
-            state.downloadedBytes = metadata.sizeBytes;
-            state.lastError = null;
-            await saveBootstrapState(paths, state);
-            await progress.setPhase("snapshot_download", {
-                resumed: false,
-                downloadedBytes: metadata.sizeBytes,
-                totalBytes: metadata.sizeBytes,
-                percent: 100,
-                bytesPerSecond: null,
-                etaSeconds: 0,
-                lastError: null,
-            });
+            await finalizeExistingSnapshot(metadata, manifest, state, { paths, progress });
             return;
         }
         catch {
-            await resetSnapshotFiles(paths);
-            state.downloadedBytes = 0;
             state.validated = false;
-            await saveBootstrapState(paths, state);
         }
     }
+    else if (state.validated) {
+        state.validated = false;
+    }
+    await reconcileSnapshotDownloadArtifacts(paths, state, manifest, snapshotIdentity);
+    await saveBootstrapState(paths, state);
+    throwIfAborted(signal);
+    if (state.downloadedBytes >= metadata.sizeBytes) {
+        await finalizeSnapshotDownload(metadata, manifest, state, { paths, progress }, state.downloadedBytes > 0);
+        return;
+    }
     let retryDelayMs = DOWNLOAD_RETRY_BASE_MS;
     while (true) {
-        let startOffset = existingPart?.size ?? (await statOrNull(paths.partialSnapshotPath))?.size ?? 0;
-        if (startOffset > metadata.sizeBytes) {
-            await rm(paths.partialSnapshotPath, { force: true });
-            startOffset = 0;
-        }
+        const startOffset = state.downloadedBytes;
         const resumed = startOffset > 0;
         try {
+            throwIfAborted(signal);
             const headers = resumed ? { Range: `bytes=${startOffset}-` } : undefined;
-            const response = await fetchImpl(metadata.url, { headers });
-            if (!(response.status === 200 || response.status === 206)) {
+            const response = await fetchImpl(metadata.url, { headers, signal });
+            if (resumed && response.status !== 206) {
+                throw new Error(response.status === 200
+                    ? "snapshot_resume_requires_partial_content"
+                    : `snapshot_http_${response.status}`);
+            }
+            if (!resumed && response.status !== 200) {
                 throw new Error(`snapshot_http_${response.status}`);
             }
             if (response.body === null) {
                 throw new Error("snapshot_response_body_missing");
             }
-            let writeFrom = startOffset;
-            if (resumed && response.status === 200) {
-                await rm(paths.partialSnapshotPath, { force: true });
-                writeFrom = 0;
-            }
-            const file = await open(paths.partialSnapshotPath, writeFrom === 0 ? "w" : "a");
+            const file = await open(paths.partialSnapshotPath, resumed ? "a" : "w");
             const reader = response.body.getReader();
             const startedAt = Date.now();
-            let downloadedBytes = writeFrom;
-            let lastPersistAt = 0;
+            const attemptStartBytes = startOffset;
+            let downloadedBytes = startOffset;
+            let currentChunkIndex = state.verifiedChunkCount;
+            let currentChunkBytes = 0;
+            let currentChunkHash = createHash("sha256");
             await progress.setPhase("snapshot_download", {
                 resumed,
                 downloadedBytes,
@@ -129,56 +202,77 @@ export async function downloadSnapshotFileForTesting(options) {
             });
             try {
                 while (true) {
+                    throwIfAborted(signal);
                     const { done, value } = await reader.read();
                     if (done) {
                         break;
                     }
-                    if (value === undefined) {
+                    if (value === undefined || value.byteLength === 0) {
                         continue;
                     }
-                    await file.write(value);
-                    downloadedBytes += value.byteLength;
-                    const now = Date.now();
-                    await updateDownloadProgress(progress, state, downloadedBytes, resumed, startedAt);
-                    if (now - lastPersistAt >= 1_000) {
-                        state.downloadedBytes = downloadedBytes;
-                        state.lastError = null;
-                        await saveBootstrapState(paths, state);
-                        lastPersistAt = now;
+                    let offset = 0;
+                    while (offset < value.byteLength) {
+                        if (currentChunkIndex >= manifest.chunkSha256s.length) {
+                            throw new Error(`snapshot_size_mismatch_${downloadedBytes + (value.byteLength - offset)}`);
+                        }
+                        const chunkSizeBytes = resolveSnapshotChunkSize(manifest, currentChunkIndex);
+                        const remainingChunkBytes = chunkSizeBytes - currentChunkBytes;
+                        const writeLength = Math.min(remainingChunkBytes, value.byteLength - offset);
+                        const segment = value.subarray(offset, offset + writeLength);
+                        await file.write(segment);
+                        currentChunkHash.update(segment);
+                        currentChunkBytes += segment.byteLength;
+                        downloadedBytes += segment.byteLength;
+                        offset += writeLength;
+                        if (currentChunkBytes === chunkSizeBytes) {
+                            const actualSha256 = currentChunkHash.digest("hex");
+                            const expectedSha256 = manifest.chunkSha256s[currentChunkIndex];
+                            if (actualSha256 !== expectedSha256) {
+                                const verifiedBytes = resolveVerifiedChunkBytes(manifest, currentChunkIndex);
+                                await file.truncate(verifiedBytes);
+                                await file.sync();
+                                throw new Error(`snapshot_chunk_sha256_mismatch_${currentChunkIndex}`);
+                            }
+                            currentChunkIndex += 1;
+                            currentChunkBytes = 0;
+                            currentChunkHash = createHash("sha256");
+                            await file.sync();
+                            await persistVerifiedChunk(state, manifest, currentChunkIndex, { paths });
+                        }
                     }
+                    await updateDownloadProgress(progress, state, attemptStartBytes, downloadedBytes, resumed, startedAt);
+                }
+                if (downloadedBytes !== metadata.sizeBytes) {
+                    throw new Error(`snapshot_download_incomplete_${downloadedBytes}`);
                 }
             }
+            catch (error) {
+                if (!isAbortError(error, signal)) {
+                    await file.truncate(state.downloadedBytes);
+                    await file.sync();
+                }
+                throw error;
+            }
             finally {
                 await file.close();
             }
-            state.downloadedBytes = downloadedBytes;
-            await saveBootstrapState(paths, state);
-            await validateSnapshotFileForTesting(paths.partialSnapshotPath, metadata);
-            await rename(paths.partialSnapshotPath, paths.snapshotPath);
-            state.validated = true;
-            state.downloadedBytes = metadata.sizeBytes;
-            state.lastError = null;
-            await saveBootstrapState(paths, state);
-            await progress.setPhase("snapshot_download", {
-                resumed,
-                downloadedBytes: metadata.sizeBytes,
-                totalBytes: metadata.sizeBytes,
-                percent: 100,
-                bytesPerSecond: null,
-                etaSeconds: 0,
-                lastError: null,
-            });
+            await finalizeSnapshotDownload(metadata, manifest, state, { paths, progress }, resumed);
             return;
         }
         catch (error) {
-            const message = formatManagedSyncErrorMessage(describeSnapshotDownloadError(error, metadata.url));
-            if (message.startsWith("snapshot_sha256_mismatch_")
-                || message.startsWith("snapshot_size_mismatch_")) {
-                await resetSnapshotFiles(paths);
-                state.downloadedBytes = 0;
+            if (isAbortError(error, signal)) {
+                const partialInfo = await statOrNull(paths.partialSnapshotPath);
+                if (partialInfo !== null) {
+                    await truncateToVerifiedFrontier(paths.partialSnapshotPath, state.downloadedBytes);
+                }
+                state.lastError = null;
                 state.validated = false;
+                await saveBootstrapState(paths, state);
+                throw createAbortError(signal);
             }
+            const message = formatManagedSyncErrorMessage(describeSnapshotDownloadError(error, metadata.url));
             state.lastError = message;
+            state.validated = false;
             await saveBootstrapState(paths, state);
             await progress.setPhase("snapshot_download", {
                 resumed,
@@ -189,7 +283,7 @@ export async function downloadSnapshotFileForTesting(options) {
                 etaSeconds: null,
                 lastError: message,
             });
-            await sleep(retryDelayMs);
+            await sleep(retryDelayMs, signal);
             retryDelayMs = Math.min(retryDelayMs * 2, DOWNLOAD_RETRY_MAX_MS);
         }
     }

package/dist/bitcoind/bootstrap/headers.d.ts

@@ -1,13 +1,27 @@
+import { type ManagedRpcRetryState } from "../retryable-rpc.js";
 import type { BitcoinRpcClient } from "../rpc.js";
 import type { ManagedProgressController } from "../progress.js";
 import type { SnapshotMetadata } from "../types.js";
 export declare function waitForHeaders(rpc: Pick<BitcoinRpcClient, "getBlockchainInfo" | "getNetworkInfo">, snapshot: SnapshotMetadata, progress: Pick<ManagedProgressController, "setPhase">, options?: {
     now?: () => number;
-    sleep?: (ms: number) => Promise<void>;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     noPeerTimeoutMs?: number;
+    signal?: AbortSignal;
+    retryState?: ManagedRpcRetryState;
+    debugLogPath?: string;
+    readDebugLogProgress?: (debugLogPath: string) => Promise<{
+        height: number;
+        message: string;
+    } | null>;
 }): Promise<void>;
 export declare function waitForHeadersForTesting(rpc: Pick<BitcoinRpcClient, "getBlockchainInfo" | "getNetworkInfo">, snapshot: SnapshotMetadata | undefined, progress: Pick<ManagedProgressController, "setPhase">, options?: {
     now?: () => number;
-    sleep?: (ms: number) => Promise<void>;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     noPeerTimeoutMs?: number;
+    signal?: AbortSignal;
+    debugLogPath?: string;
+    readDebugLogProgress?: (debugLogPath: string) => Promise<{
+        height: number;
+        message: string;
+    } | null>;
 }): Promise<void>;

package/dist/bitcoind/bootstrap/headers.js

@@ -1,8 +1,35 @@
+import { open } from "node:fs/promises";
 import { formatManagedSyncErrorMessage } from "../errors.js";
+import { MANAGED_RPC_RETRY_MESSAGE, consumeManagedRpcRetryDelayMs, createManagedRpcRetryState, describeManagedRpcRetryError, resetManagedRpcRetryState, isRetryableManagedRpcError, } from "../retryable-rpc.js";
 import { DEFAULT_SNAPSHOT_METADATA, HEADER_NO_PEER_TIMEOUT_MS, HEADER_POLL_MS, } from "./constants.js";
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
+const DEBUG_LOG_TAIL_BYTES = 64 * 1024;
+const HEADER_SYNC_DEBUG_LINE_PATTERN = /Pre-synchronizing blockheaders,\s*height:\s*([\d,]+)\s*\(~(\d+(?:\.\d+)?)%\)/u;
+function createAbortError(signal) {
+    const reason = signal?.reason;
+    if (reason instanceof Error) {
+        return reason;
+    }
+    const error = new Error("managed_sync_aborted");
+    error.name = "AbortError";
+    return error;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal);
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject(createAbortError(signal));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
 function resolvePeerCount(networkInfo) {
@@ -10,7 +37,52 @@ function resolvePeerCount(networkInfo) {
         ? networkInfo.connections
         : (networkInfo.connections_in ?? 0) + (networkInfo.connections_out ?? 0);
 }
-function resolveHeaderWaitMessage(headers, peerCount, networkActive) {
+async function readDebugLogTail(filePath, maxBytes = DEBUG_LOG_TAIL_BYTES) {
+    let handle = null;
+    try {
+        handle = await open(filePath, "r");
+        const stats = await handle.stat();
+        const bytesToRead = Math.min(maxBytes, Math.max(0, stats.size));
+        if (bytesToRead === 0) {
+            return null;
+        }
+        const buffer = Buffer.alloc(bytesToRead);
+        await handle.read(buffer, 0, bytesToRead, stats.size - bytesToRead);
+        return buffer.toString("utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => { });
+    }
+}
+async function readHeaderSyncProgressFromDebugLog(debugLogPath) {
+    const tail = await readDebugLogTail(debugLogPath);
+    if (tail === null) {
+        return null;
+    }
+    const lines = tail.split(/\r?\n/u).reverse();
+    for (const line of lines) {
+        const match = HEADER_SYNC_DEBUG_LINE_PATTERN.exec(line);
+        if (match === null) {
+            continue;
+        }
+        const height = Number(match[1].replaceAll(",", ""));
+        if (!Number.isFinite(height) || height < 0) {
+            return null;
+        }
+        return {
+            height,
+            message: `Pre-synchronizing blockheaders, height: ${height.toLocaleString()} (~${match[2]}%)`,
+        };
+    }
+    return null;
+}
+function resolveHeaderWaitMessage(headers, peerCount, networkActive, rpcHeaders, headerSyncMessage) {
     if (!networkActive) {
         return "Bitcoin networking is inactive for the managed node.";
     }
@@ -20,31 +92,69 @@ function resolveHeaderWaitMessage(headers, peerCount, networkActive) {
     if (peerCount === 0) {
         return `Waiting for peers to continue header sync (${headers.toLocaleString()} headers, 0 peers).`;
     }
-    return "Waiting for Bitcoin headers to reach the snapshot height.";
+    if (rpcHeaders > 0) {
+        return "Waiting for Bitcoin headers to reach the snapshot height.";
+    }
+    return headerSyncMessage ?? "Pre-synchronizing blockheaders.";
 }
 export async function waitForHeaders(rpc, snapshot, progress, options = {}) {
     const now = options.now ?? Date.now;
     const sleepImpl = options.sleep ?? sleep;
     const noPeerTimeoutMs = options.noPeerTimeoutMs ?? HEADER_NO_PEER_TIMEOUT_MS;
+    const { signal } = options;
+    const retryState = options.retryState ?? createManagedRpcRetryState();
+    const readDebugLogProgress = options.readDebugLogProgress ?? readHeaderSyncProgressFromDebugLog;
     let noPeerSince = null;
+    let lastBlocks = 0;
+    let lastHeaders = 0;
     while (true) {
-        const [info, networkInfo] = await Promise.all([
-            rpc.getBlockchainInfo(),
-            rpc.getNetworkInfo(),
-        ]);
+        throwIfAborted(signal);
+        let info;
+        let networkInfo;
+        try {
+            [info, networkInfo] = await Promise.all([
+                rpc.getBlockchainInfo(),
+                rpc.getNetworkInfo(),
+            ]);
+            resetManagedRpcRetryState(retryState);
+        }
+        catch (error) {
+            if (!isRetryableManagedRpcError(error)) {
+                throw error;
+            }
+            await progress.setPhase("wait_headers_for_snapshot", {
+                headers: lastHeaders,
+                targetHeight: snapshot.height,
+                blocks: lastBlocks,
+                percent: (Math.min(lastHeaders, snapshot.height) / snapshot.height) * 100,
+                lastError: describeManagedRpcRetryError(error),
+                message: MANAGED_RPC_RETRY_MESSAGE,
+            });
+            await sleepImpl(consumeManagedRpcRetryDelayMs(retryState), signal);
+            continue;
+        }
+        lastBlocks = info.blocks;
+        const debugLogProgress = info.headers === 0 && options.debugLogPath !== undefined
+            ? await readDebugLogProgress(options.debugLogPath)
+            : null;
+        const observedHeaders = info.headers > 0
+            ? info.headers
+            : Math.max(info.headers, debugLogProgress?.height ?? 0);
+        lastHeaders = observedHeaders;
         const peerCount = resolvePeerCount(networkInfo);
-        const message = resolveHeaderWaitMessage(info.headers, peerCount, networkInfo.networkactive);
+        const message = resolveHeaderWaitMessage(observedHeaders, peerCount, networkInfo.networkactive, info.headers, debugLogProgress?.message ?? null);
         await progress.setPhase("wait_headers_for_snapshot", {
-            headers: info.headers,
+            headers: observedHeaders,
             targetHeight: snapshot.height,
             blocks: info.blocks,
-            percent: (Math.min(info.headers, snapshot.height) / snapshot.height) * 100,
+            percent: (Math.min(observedHeaders, snapshot.height) / snapshot.height) * 100,
+            lastError: null,
             message,
         });
         if (info.headers >= snapshot.height) {
             return;
         }
-        if (info.headers === 0 && peerCount === 0) {
+        if (observedHeaders === 0 && peerCount === 0) {
             noPeerSince ??= now();
             if (now() - noPeerSince >= noPeerTimeoutMs) {
                 throw new Error(formatManagedSyncErrorMessage("bitcoind_no_peers_for_header_sync_check_internet_or_firewall"));
@@ -53,7 +163,7 @@ export async function waitForHeaders(rpc, snapshot, progress, options = {}) {
         else {
             noPeerSince = null;
         }
-        await sleepImpl(HEADER_POLL_MS);
+        await sleepImpl(HEADER_POLL_MS, signal);
     }
 }
 export async function waitForHeadersForTesting(rpc, snapshot = DEFAULT_SNAPSHOT_METADATA, progress, options) {

package/dist/bitcoind/bootstrap/state.d.ts

@@ -1,11 +1,15 @@
-import type { BootstrapPaths, BootstrapPersistentState } from "./types.js";
+import type { BootstrapPaths, BootstrapPersistentState, LoadedBootstrapState } from "./types.js";
 import type { BootstrapPhase, SnapshotMetadata } from "../types.js";
+export declare function loadBootstrapStateRecord(paths: BootstrapPaths, snapshot: SnapshotMetadata): Promise<LoadedBootstrapState>;
 export declare function loadBootstrapState(paths: BootstrapPaths, snapshot: SnapshotMetadata): Promise<BootstrapPersistentState>;
 export declare function saveBootstrapState(paths: BootstrapPaths, state: BootstrapPersistentState): Promise<void>;
 export declare function createBootstrapStateForTesting(snapshot?: SnapshotMetadata): {
     metadataVersion: number;
     snapshot: SnapshotMetadata;
     phase: BootstrapPhase;
+    integrityVersion: number;
+    chunkSizeBytes: number;
+    verifiedChunkCount: number;
     downloadedBytes: number;
     validated: boolean;
     loadTxOutSetComplete: boolean;
@@ -18,6 +22,9 @@ export declare function loadBootstrapStateForTesting(paths: BootstrapPaths, snap
     metadataVersion: number;
     snapshot: SnapshotMetadata;
     phase: BootstrapPhase;
+    integrityVersion: number;
+    chunkSizeBytes: number;
+    verifiedChunkCount: number;
     downloadedBytes: number;
     validated: boolean;
     loadTxOutSetComplete: boolean;
@@ -30,6 +37,9 @@ export declare function saveBootstrapStateForTesting(paths: BootstrapPaths, stat
     metadataVersion: number;
     snapshot: SnapshotMetadata;
     phase: BootstrapPhase;
+    integrityVersion: number;
+    chunkSizeBytes: number;
+    verifiedChunkCount: number;
     downloadedBytes: number;
     validated: boolean;
     loadTxOutSetComplete: boolean;