@cogcoin/client 0.5.4 → 0.5.5

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

@@ -3,11 +3,13 @@ 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;
 }): 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;
 }): Promise<void>;

package/dist/bitcoind/bootstrap/headers.js

@@ -1,8 +1,31 @@
 import { formatManagedSyncErrorMessage } from "../errors.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);
+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) {
@@ -26,8 +49,10 @@ 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;
     let noPeerSince = null;
     while (true) {
+        throwIfAborted(signal);
         const [info, networkInfo] = await Promise.all([
             rpc.getBlockchainInfo(),
             rpc.getNetworkInfo(),
@@ -53,7 +78,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;

package/dist/bitcoind/bootstrap/state.js

@@ -1,11 +1,14 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { DEFAULT_SNAPSHOT_METADATA, SNAPSHOT_METADATA_VERSION, } from "./constants.js";
+import { BOOTSTRAP_STATE_VERSION, DEFAULT_SNAPSHOT_METADATA, } from "./constants.js";
 function createInitialBootstrapState(snapshot) {
     return {
-        metadataVersion: SNAPSHOT_METADATA_VERSION,
+        metadataVersion: BOOTSTRAP_STATE_VERSION,
         snapshot,
         phase: "snapshot_download",
+        integrityVersion: 0,
+        chunkSizeBytes: 0,
+        verifiedChunkCount: 0,
         downloadedBytes: 0,
         validated: false,
         loadTxOutSetComplete: false,
@@ -21,30 +24,48 @@ async function writeJsonAtomic(path, payload) {
     await writeFile(tempPath, JSON.stringify(payload, null, 2));
     await rename(tempPath, path);
 }
-export async function loadBootstrapState(paths, snapshot) {
+function snapshotIdentityMatches(parsed, snapshot) {
+    return parsed.snapshot?.sha256 === snapshot.sha256
+        && parsed.snapshot?.sizeBytes === snapshot.sizeBytes
+        && parsed.snapshot?.height === snapshot.height
+        && parsed.snapshot?.filename === snapshot.filename;
+}
+function normalizeLoadedBootstrapState(parsed, snapshot) {
+    if (typeof parsed.downloadedBytes !== "number"
+        || typeof parsed.validated !== "boolean"
+        || typeof parsed.loadTxOutSetComplete !== "boolean") {
+        return null;
+    }
+    return {
+        metadataVersion: BOOTSTRAP_STATE_VERSION,
+        snapshot,
+        phase: parsed.phase ?? "snapshot_download",
+        integrityVersion: typeof parsed.integrityVersion === "number" ? parsed.integrityVersion : 0,
+        chunkSizeBytes: typeof parsed.chunkSizeBytes === "number" ? parsed.chunkSizeBytes : 0,
+        verifiedChunkCount: typeof parsed.verifiedChunkCount === "number" ? parsed.verifiedChunkCount : 0,
+        downloadedBytes: parsed.downloadedBytes,
+        validated: parsed.validated,
+        loadTxOutSetComplete: parsed.loadTxOutSetComplete,
+        baseHeight: parsed.baseHeight ?? null,
+        tipHashHex: parsed.tipHashHex ?? null,
+        lastError: parsed.lastError ?? null,
+        updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+    };
+}
+export async function loadBootstrapStateRecord(paths, snapshot) {
     try {
         const raw = await readFile(paths.statePath, "utf8");
         const parsed = JSON.parse(raw);
-        if (parsed.metadataVersion === SNAPSHOT_METADATA_VERSION
-            && parsed.snapshot?.url === snapshot.url
-            && parsed.snapshot?.sha256 === snapshot.sha256
-            && parsed.snapshot?.sizeBytes === snapshot.sizeBytes
-            && parsed.snapshot?.height === snapshot.height
-            && parsed.snapshot?.filename === snapshot.filename
-            && typeof parsed.downloadedBytes === "number"
-            && typeof parsed.validated === "boolean"
-            && typeof parsed.loadTxOutSetComplete === "boolean") {
+        const snapshotIdentity = parsed.snapshot === undefined
+            ? "unknown"
+            : snapshotIdentityMatches(parsed, snapshot)
+                ? "current"
+                : "different";
+        const normalized = normalizeLoadedBootstrapState(parsed, snapshot);
+        if (normalized !== null) {
             return {
-                metadataVersion: SNAPSHOT_METADATA_VERSION,
-                snapshot,
-                phase: parsed.phase ?? "snapshot_download",
-                downloadedBytes: parsed.downloadedBytes,
-                validated: parsed.validated,
-                loadTxOutSetComplete: parsed.loadTxOutSetComplete,
-                baseHeight: parsed.baseHeight ?? null,
-                tipHashHex: parsed.tipHashHex ?? null,
-                lastError: parsed.lastError ?? null,
-                updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+                state: normalized,
+                snapshotIdentity,
             };
         }
     }
@@ -53,7 +74,13 @@ export async function loadBootstrapState(paths, snapshot) {
     }
     const state = createInitialBootstrapState(snapshot);
     await writeJsonAtomic(paths.statePath, state);
-    return state;
+    return {
+        state,
+        snapshotIdentity: "unknown",
+    };
+}
+export async function loadBootstrapState(paths, snapshot) {
+    return (await loadBootstrapStateRecord(paths, snapshot)).state;
 }
 export async function saveBootstrapState(paths, state) {
     state.updatedAt = Date.now();

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

@@ -1,9 +1,12 @@
 import type { ManagedProgressController } from "../progress.js";
-import type { BootstrapPhase, SnapshotMetadata } from "../types.js";
+import type { BootstrapPhase, SnapshotChunkManifest, SnapshotMetadata } from "../types.js";
 export interface BootstrapPersistentState {
     metadataVersion: number;
     snapshot: SnapshotMetadata;
     phase: BootstrapPhase;
+    integrityVersion: number;
+    chunkSizeBytes: number;
+    verifiedChunkCount: number;
     downloadedBytes: number;
     validated: boolean;
     loadTxOutSetComplete: boolean;
@@ -12,6 +15,11 @@ export interface BootstrapPersistentState {
     lastError: string | null;
     updatedAt: number;
 }
+export type BootstrapStateSnapshotIdentity = "current" | "different" | "unknown";
+export interface LoadedBootstrapState {
+    state: BootstrapPersistentState;
+    snapshotIdentity: BootstrapStateSnapshotIdentity;
+}
 export interface BootstrapPaths {
     directory: string;
     snapshotPath: string;
@@ -22,7 +30,10 @@ export interface BootstrapPaths {
 export interface DownloadSnapshotOptions {
     fetchImpl?: typeof fetch;
     metadata: SnapshotMetadata;
+    manifest?: SnapshotChunkManifest;
     paths: BootstrapPaths;
     progress: Pick<ManagedProgressController, "setPhase">;
     state: BootstrapPersistentState;
+    signal?: AbortSignal;
+    snapshotIdentity?: BootstrapStateSnapshotIdentity;
 }

package/dist/bitcoind/client/internal-types.d.ts

@@ -23,6 +23,7 @@ export interface SyncEngineDependencies {
     startHeight: number;
     bitcoinRateTracker: BlockRateTracker;
     cogcoinRateTracker: BlockRateTracker;
+    abortSignal?: AbortSignal;
     isFollowing(): boolean;
     loadVisibleFollowBlockTimes(tip: Awaited<ReturnType<Client["getTip"]>>): Promise<Record<number, number>>;
 }

package/dist/bitcoind/client/managed-client.js

@@ -21,6 +21,7 @@ export class DefaultManagedBitcoindClient {
     #cogcoinRateTracker = createBlockRateTracker();
     #syncPromise = Promise.resolve(createInitialSyncResult());
     #debounceTimer = null;
+    #syncAbortControllers = new Set();
     constructor(client, store, node, rpc, progress, bootstrap, indexerDaemon, syncDebounceMs) {
         this.#client = client;
         this.#store = store;
@@ -47,19 +48,29 @@ export class DefaultManagedBitcoindClient {
     async syncToTip() {
         this.#assertOpen();
         await this.#progress.start();
-        const run = async () => runManagedSync({
-            client: this.#client,
-            store: this.#store,
-            node: this.#node,
-            rpc: this.#rpc,
-            progress: this.#progress,
-            bootstrap: this.#bootstrap,
-            startHeight: this.#startHeight,
-            bitcoinRateTracker: this.#bitcoinRateTracker,
-            cogcoinRateTracker: this.#cogcoinRateTracker,
-            isFollowing: () => this.#following,
-            loadVisibleFollowBlockTimes: (tip) => this.#loadVisibleFollowBlockTimes(tip),
-        });
+        const run = async () => {
+            const abortController = new AbortController();
+            this.#syncAbortControllers.add(abortController);
+            try {
+                return await runManagedSync({
+                    client: this.#client,
+                    store: this.#store,
+                    node: this.#node,
+                    rpc: this.#rpc,
+                    progress: this.#progress,
+                    bootstrap: this.#bootstrap,
+                    startHeight: this.#startHeight,
+                    bitcoinRateTracker: this.#bitcoinRateTracker,
+                    cogcoinRateTracker: this.#cogcoinRateTracker,
+                    abortSignal: abortController.signal,
+                    isFollowing: () => this.#following,
+                    loadVisibleFollowBlockTimes: (tip) => this.#loadVisibleFollowBlockTimes(tip),
+                });
+            }
+            finally {
+                this.#syncAbortControllers.delete(abortController);
+            }
+        };
         const nextPromise = this.#syncPromise.then(run, run);
         this.#syncPromise = nextPromise;
         return nextPromise;
@@ -159,6 +170,9 @@ export class DefaultManagedBitcoindClient {
         this.#subscriber = null;
         this.#followLoop = null;
         this.#pollTimer = null;
+        for (const abortController of this.#syncAbortControllers) {
+            abortController.abort(new Error("managed_sync_aborted"));
+        }
         await this.#syncPromise.catch(() => undefined);
         await this.#progress.close();
         await this.#node.stop();