@cogcoin/client 0.5.8 → 0.5.10

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@0.5.8` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@0.5.10` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 
@@ -107,7 +107,7 @@ The built-in managed-node integration:
 - uses RPC for durable reads and ZMQ `hashblock` notifications for tip following
 - launches a local full node with cookie auth
 - defaults to an assumeutxo-first mainnet bootstrap using `https://snapshots.cogcoin.org/utxo-910000.dat`
-- opportunistically loads the public getblock archive family from `https://snapshots.cogcoin.org/getblock-910000-latest.{json,dat}` to accelerate post-`910000` Bitcoin Core catch-up
+- opportunistically loads the public getblock range family from `https://snapshots.cogcoin.org/getblock-manifest.json` plus immutable `getblock-<first>-<last>.dat` bands to accelerate post-`910000` Bitcoin Core catch-up
 - composes the existing SQLite-backed client rather than replacing it
 
 If `dataDir` is omitted, the managed node defaults to:
@@ -121,15 +121,16 @@ On a fresh mainnet managed sync, `syncToTip()` or `startFollowingTip()`:
 1. downloads the pinned Cogcoin UTXO snapshot with resume support
 2. validates its known size and SHA-256
 3. loads it with Bitcoin Core assumeutxo
-4. opportunistically downloads and validates the public getblock archive for raw post-snapshot Bitcoin blocks
-5. loads that archive into managed Bitcoin Core when available
-6. continues Bitcoin sync and Cogcoin replay from the managed node until the live tip is caught up
+4. opportunistically checks for the next published 500-block getblock band at each post-snapshot boundary
+5. downloads, validates, and loads that range into managed Bitcoin Core when available
+6. syncs Cogcoin through that range, deletes the consumed local band cache, and repeats for the next boundary
+7. falls back to ordinary Bitcoin sync and Cogcoin replay once no further published range exists
 
-The public getblock archive provenance is tracked in the companion scraper repository:
+The public getblock range provenance is tracked in the companion scraper repository:
 
 - [`github.com/cogcoin/bitcoin-scrape`](https://github.com/cogcoin/bitcoin-scrape)
 
-That repo documents how the `getblock-910000-latest.dat` and `getblock-910000-latest.json` artifacts are assembled from `bitcoin-cli getblockhash` plus `bitcoin-cli getblock <hash> 0`, including the blk-style file layout, manifest format, durability guarantees, and height-based cache-busting rules.
+That repo documents how `getblock-manifest.json` and immutable files such as `getblock-910001-910500.dat` and `getblock-910501-911000.dat` are assembled from `bitcoin-cli getblockhash` plus `bitcoin-cli getblock <hash> 0`, including the blk-style file layout, range manifest format, durability guarantees, and publish order.
 
 The managed `bitcoind` client also exposes:
 

package/dist/bitcoind/bootstrap/getblock-archive.d.ts

@@ -4,17 +4,27 @@ interface GetblockArchivePaths {
     directory: string;
     artifactPath: string;
     partialArtifactPath: string;
-    manifestPath: string;
-    partialManifestPath: string;
     statePath: string;
 }
 export interface ReadyGetblockArchive {
     manifest: GetblockArchiveManifest;
     artifactPath: string;
-    manifestPath: string;
 }
-export declare function resolveGetblockArchivePathsForTesting(dataDir: string): GetblockArchivePaths;
-export declare function resolveReadyGetblockArchiveForTesting(dataDir: string): Promise<ReadyGetblockArchive | null>;
+export declare function resolveGetblockArchivePathsForTesting(dataDir: string, firstBlockHeight?: number, lastBlockHeight?: number): GetblockArchivePaths;
+export declare function resolveReadyGetblockArchiveForTesting(dataDir: string, manifest: GetblockArchiveManifest): Promise<ReadyGetblockArchive | null>;
+export declare function prepareGetblockArchiveRange(options: {
+    dataDir: string;
+    progress: Pick<ManagedProgressController, "setPhase">;
+    firstBlockHeight: number;
+    lastBlockHeight: number;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<ReadyGetblockArchive | null>;
+export declare function deleteGetblockArchiveRange(options: {
+    dataDir: string;
+    firstBlockHeight: number;
+    lastBlockHeight: number;
+}): Promise<void>;
 export declare function prepareLatestGetblockArchive(options: {
     dataDir: string;
     progress: Pick<ManagedProgressController, "setPhase">;
@@ -22,6 +32,8 @@ export declare function prepareLatestGetblockArchive(options: {
     signal?: AbortSignal;
 }): Promise<ReadyGetblockArchive | null>;
 export declare const prepareLatestGetblockArchiveForTesting: typeof prepareLatestGetblockArchive;
+export declare const prepareGetblockArchiveRangeForTesting: typeof prepareGetblockArchiveRange;
+export declare const deleteGetblockArchiveRangeForTesting: typeof deleteGetblockArchiveRange;
 export declare function waitForGetblockArchiveImportForTesting(rpc: Pick<{
     getBlockchainInfo(): Promise<{
         blocks: number;

package/dist/bitcoind/bootstrap/getblock-archive.js

@@ -4,18 +4,22 @@ import { dirname, join } from "node:path";
 import { DOWNLOAD_RETRY_BASE_MS, DOWNLOAD_RETRY_MAX_MS } from "./constants.js";
 const GETBLOCK_ARCHIVE_STATE_VERSION = 1;
 const GETBLOCK_ARCHIVE_BASE_HEIGHT = 910_000;
-const GETBLOCK_ARCHIVE_FILENAME = "getblock-910000-latest.dat";
-const GETBLOCK_ARCHIVE_MANIFEST_FILENAME = "getblock-910000-latest.json";
-const GETBLOCK_ARCHIVE_REMOTE_DATA_URL = "https://snapshots.cogcoin.org/getblock-910000-latest.dat";
-const GETBLOCK_ARCHIVE_REMOTE_MANIFEST_URL = "https://snapshots.cogcoin.org/getblock-910000-latest.json";
+const GETBLOCK_ARCHIVE_RANGE_SIZE = 500;
+const GETBLOCK_ARCHIVE_FIRST_HEIGHT = GETBLOCK_ARCHIVE_BASE_HEIGHT + 1;
+const GETBLOCK_ARCHIVE_REMOTE_BASE_URL = "https://snapshots.cogcoin.org/";
+const GETBLOCK_ARCHIVE_REMOTE_MANIFEST_URL = `${GETBLOCK_ARCHIVE_REMOTE_BASE_URL}getblock-manifest.json`;
 const TRUSTED_FRONTIER_REVERIFY_CHUNKS = 2;
 const HASH_READ_BUFFER_BYTES = 1024 * 1024;
 const IMPORT_POLL_MS = 2_000;
+function buildRangeFilename(firstBlockHeight, lastBlockHeight) {
+    return `getblock-${firstBlockHeight}-${lastBlockHeight}.dat`;
+}
 function createInitialState() {
     return {
         metadataVersion: GETBLOCK_ARCHIVE_STATE_VERSION,
         formatVersion: 0,
-        endHeight: null,
+        firstBlockHeight: null,
+        lastBlockHeight: null,
         artifactSizeBytes: 0,
         artifactSha256: null,
         chunkSizeBytes: 0,
@@ -26,35 +30,74 @@ function createInitialState() {
         updatedAt: Date.now(),
     };
 }
-function assertManifestShape(parsed) {
+function assertRangeManifestShape(parsed) {
     if (typeof parsed !== "object" || parsed === null) {
         throw new Error("managed_getblock_archive_manifest_invalid");
     }
     const manifest = parsed;
-    if (manifest.chain !== "main"
+    if (manifest.formatVersion !== 1
+        || manifest.chain !== "main"
         || manifest.baseSnapshotHeight !== GETBLOCK_ARCHIVE_BASE_HEIGHT
-        || manifest.artifactFilename !== GETBLOCK_ARCHIVE_FILENAME
         || typeof manifest.firstBlockHeight !== "number"
-        || typeof manifest.endHeight !== "number"
-        || typeof manifest.blockCount !== "number"
+        || typeof manifest.lastBlockHeight !== "number"
+        || typeof manifest.artifactFilename !== "string"
         || typeof manifest.artifactSizeBytes !== "number"
         || typeof manifest.artifactSha256 !== "string"
         || typeof manifest.chunkSizeBytes !== "number"
         || !Array.isArray(manifest.chunkSha256s)
-        || !Array.isArray(manifest.blocks)) {
+        || manifest.chunkSha256s.some((hash) => typeof hash !== "string")) {
+        throw new Error("managed_getblock_archive_manifest_invalid");
+    }
+    if (manifest.lastBlockHeight - manifest.firstBlockHeight + 1 !== GETBLOCK_ARCHIVE_RANGE_SIZE
+        || manifest.artifactFilename !== buildRangeFilename(manifest.firstBlockHeight, manifest.lastBlockHeight)) {
         throw new Error("managed_getblock_archive_manifest_invalid");
     }
     return manifest;
 }
-function resolvePaths(dataDir) {
+function assertAggregateManifestShape(parsed) {
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new Error("managed_getblock_archive_manifest_invalid");
+    }
+    const manifest = parsed;
+    if (manifest.formatVersion !== 1
+        || manifest.chain !== "main"
+        || manifest.baseSnapshotHeight !== GETBLOCK_ARCHIVE_BASE_HEIGHT
+        || manifest.rangeSizeBlocks !== GETBLOCK_ARCHIVE_RANGE_SIZE
+        || typeof manifest.publishedThroughHeight !== "number"
+        || !Array.isArray(manifest.ranges)) {
+        throw new Error("managed_getblock_archive_manifest_invalid");
+    }
+    const ranges = manifest.ranges.map((entry) => assertRangeManifestShape(entry));
+    let expectedFirstBlockHeight = GETBLOCK_ARCHIVE_FIRST_HEIGHT;
+    for (const range of ranges) {
+        if (range.firstBlockHeight !== expectedFirstBlockHeight) {
+            throw new Error("managed_getblock_archive_manifest_invalid");
+        }
+        expectedFirstBlockHeight = range.lastBlockHeight + 1;
+    }
+    const expectedPublishedThrough = ranges.length === 0
+        ? GETBLOCK_ARCHIVE_BASE_HEIGHT
+        : ranges[ranges.length - 1].lastBlockHeight;
+    if (manifest.publishedThroughHeight !== expectedPublishedThrough) {
+        throw new Error("managed_getblock_archive_manifest_invalid");
+    }
+    return {
+        formatVersion: manifest.formatVersion,
+        chain: manifest.chain,
+        baseSnapshotHeight: manifest.baseSnapshotHeight,
+        rangeSizeBlocks: manifest.rangeSizeBlocks,
+        publishedThroughHeight: manifest.publishedThroughHeight,
+        ranges,
+    };
+}
+function resolvePaths(dataDir, firstBlockHeight, lastBlockHeight) {
     const directory = join(dataDir, "bootstrap", "getblock");
+    const artifactFilename = buildRangeFilename(firstBlockHeight, lastBlockHeight);
     return {
         directory,
-        artifactPath: join(directory, GETBLOCK_ARCHIVE_FILENAME),
-        partialArtifactPath: join(directory, `${GETBLOCK_ARCHIVE_FILENAME}.part`),
-        manifestPath: join(directory, GETBLOCK_ARCHIVE_MANIFEST_FILENAME),
-        partialManifestPath: join(directory, `${GETBLOCK_ARCHIVE_MANIFEST_FILENAME}.part`),
-        statePath: join(directory, "state.json"),
+        artifactPath: join(directory, artifactFilename),
+        partialArtifactPath: join(directory, `${artifactFilename}.part`),
+        statePath: join(directory, `getblock-${firstBlockHeight}-${lastBlockHeight}.state.json`),
     };
 }
 async function statOrNull(path) {
@@ -74,17 +117,6 @@ async function writeJsonAtomic(path, payload) {
     await writeFile(tempPath, JSON.stringify(payload, null, 2));
     await rename(tempPath, path);
 }
-async function readManifest(path) {
-    try {
-        return assertManifestShape(JSON.parse(await readFile(path, "utf8")));
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
 async function loadState(paths) {
     try {
         const parsed = JSON.parse(await readFile(paths.statePath, "utf8"));
@@ -94,7 +126,8 @@ async function loadState(paths) {
         return {
             metadataVersion: GETBLOCK_ARCHIVE_STATE_VERSION,
             formatVersion: typeof parsed.formatVersion === "number" ? parsed.formatVersion : 0,
-            endHeight: typeof parsed.endHeight === "number" ? parsed.endHeight : null,
+            firstBlockHeight: typeof parsed.firstBlockHeight === "number" ? parsed.firstBlockHeight : null,
+            lastBlockHeight: typeof parsed.lastBlockHeight === "number" ? parsed.lastBlockHeight : null,
             artifactSizeBytes: typeof parsed.artifactSizeBytes === "number" ? parsed.artifactSizeBytes : 0,
             artifactSha256: typeof parsed.artifactSha256 === "string" ? parsed.artifactSha256 : null,
             chunkSizeBytes: typeof parsed.chunkSizeBytes === "number" ? parsed.chunkSizeBytes : 0,
@@ -145,7 +178,8 @@ function resolveVerifiedChunkCountFromBytes(manifest, bytes) {
     return verifiedChunkCount;
 }
 function stateMatchesManifest(state, manifest) {
-    return state.endHeight === manifest.endHeight
+    return state.firstBlockHeight === manifest.firstBlockHeight
+        && state.lastBlockHeight === manifest.lastBlockHeight
         && state.artifactSha256 === manifest.artifactSha256
         && state.artifactSizeBytes === manifest.artifactSizeBytes
         && state.chunkSizeBytes === manifest.chunkSizeBytes
@@ -211,25 +245,15 @@ async function truncateFile(path, size) {
     }
 }
 async function reconcilePartialDownloadArtifacts(paths, manifest, state) {
-    const partialManifest = await readManifest(paths.partialManifestPath).catch(() => null);
-    if (partialManifest === null || partialManifest.endHeight !== manifest.endHeight || partialManifest.artifactSha256 !== manifest.artifactSha256) {
+    const partialInfo = await statOrNull(paths.partialArtifactPath);
+    if (partialInfo === null || !stateMatchesManifest(state, manifest)) {
         await rm(paths.partialArtifactPath, { force: true }).catch(() => undefined);
-        await rm(paths.partialManifestPath, { force: true }).catch(() => undefined);
         state.formatVersion = manifest.formatVersion;
-        state.endHeight = manifest.endHeight;
+        state.firstBlockHeight = manifest.firstBlockHeight;
+        state.lastBlockHeight = manifest.lastBlockHeight;
         state.artifactSizeBytes = manifest.artifactSizeBytes;
         state.artifactSha256 = manifest.artifactSha256;
         state.chunkSizeBytes = manifest.chunkSizeBytes;
-        state.verifiedChunkCount = 0;
-        state.downloadedBytes = 0;
-        state.validated = false;
-        state.lastError = null;
-        await writeJsonAtomic(paths.partialManifestPath, manifest);
-        await saveState(paths, state);
-        return;
-    }
-    const partialInfo = await statOrNull(paths.partialArtifactPath);
-    if (partialInfo === null) {
         state.verifiedChunkCount = 0;
         state.downloadedBytes = 0;
         state.validated = false;
@@ -246,7 +270,8 @@ async function reconcilePartialDownloadArtifacts(paths, manifest, state) {
         await truncateFile(paths.partialArtifactPath, verifiedBytes);
     }
     state.formatVersion = manifest.formatVersion;
-    state.endHeight = manifest.endHeight;
+    state.firstBlockHeight = manifest.firstBlockHeight;
+    state.lastBlockHeight = manifest.lastBlockHeight;
     state.artifactSizeBytes = manifest.artifactSizeBytes;
     state.artifactSha256 = manifest.artifactSha256;
     state.chunkSizeBytes = manifest.chunkSizeBytes;
@@ -304,14 +329,14 @@ async function updateDownloadProgress(progress, manifest, state, startedAtUnixMs
     const bytesPerSecond = Math.max(0, (downloadedBytes - attemptStartBytes) / elapsedSeconds);
     const remaining = Math.max(0, manifest.artifactSizeBytes - downloadedBytes);
     await progress.setPhase("getblock_archive_download", {
-        message: "Downloading getblock archive.",
+        message: "Downloading getblock range.",
         resumed: downloadedBytes > 0,
         downloadedBytes,
         totalBytes: manifest.artifactSizeBytes,
         percent: manifest.artifactSizeBytes > 0 ? (downloadedBytes / manifest.artifactSizeBytes) * 100 : 0,
         bytesPerSecond,
         etaSeconds: bytesPerSecond > 0 ? remaining / bytesPerSecond : null,
-        targetHeight: manifest.endHeight,
+        targetHeight: manifest.lastBlockHeight,
         lastError: state.lastError,
     });
 }
@@ -320,7 +345,6 @@ async function downloadRemoteArchive(paths, manifest, state, progress, fetchImpl
     if (state.downloadedBytes >= manifest.artifactSizeBytes) {
         await validateWholeFile(paths.partialArtifactPath, manifest);
         await rename(paths.partialArtifactPath, paths.artifactPath);
-        await rename(paths.partialManifestPath, paths.manifestPath);
         state.validated = true;
         state.verifiedChunkCount = manifest.chunkSha256s.length;
         state.downloadedBytes = manifest.artifactSizeBytes;
@@ -332,7 +356,7 @@ async function downloadRemoteArchive(paths, manifest, state, progress, fetchImpl
     while (true) {
         const startOffset = state.downloadedBytes;
         try {
-            const response = await fetchImpl(`${GETBLOCK_ARCHIVE_REMOTE_DATA_URL}?end=${manifest.endHeight}`, {
+            const response = await fetchImpl(`${GETBLOCK_ARCHIVE_REMOTE_BASE_URL}${manifest.artifactFilename}`, {
                 headers: startOffset > 0 ? { Range: `bytes=${startOffset}-` } : undefined,
                 signal,
             });
@@ -401,21 +425,20 @@ async function downloadRemoteArchive(paths, manifest, state, progress, fetchImpl
             }
             await validateWholeFile(paths.partialArtifactPath, manifest);
             await rename(paths.partialArtifactPath, paths.artifactPath);
-            await rename(paths.partialManifestPath, paths.manifestPath);
             state.validated = true;
             state.verifiedChunkCount = manifest.chunkSha256s.length;
             state.downloadedBytes = manifest.artifactSizeBytes;
             state.lastError = null;
             await saveState(paths, state);
             await progress.setPhase("getblock_archive_download", {
-                message: "Downloading getblock archive.",
+                message: "Downloading getblock range.",
                 resumed: startOffset > 0,
                 downloadedBytes: manifest.artifactSizeBytes,
                 totalBytes: manifest.artifactSizeBytes,
                 percent: 100,
                 bytesPerSecond: null,
                 etaSeconds: 0,
-                targetHeight: manifest.endHeight,
+                targetHeight: manifest.lastBlockHeight,
                 lastError: null,
             });
             return;
@@ -427,14 +450,14 @@ async function downloadRemoteArchive(paths, manifest, state, progress, fetchImpl
                 throw error;
             }
             await progress.setPhase("getblock_archive_download", {
-                message: "Downloading getblock archive.",
+                message: "Downloading getblock range.",
                 resumed: startOffset > 0,
                 downloadedBytes: state.downloadedBytes,
                 totalBytes: manifest.artifactSizeBytes,
                 percent: manifest.artifactSizeBytes > 0 ? (state.downloadedBytes / manifest.artifactSizeBytes) * 100 : 0,
                 bytesPerSecond: null,
                 etaSeconds: null,
-                targetHeight: manifest.endHeight,
+                targetHeight: manifest.lastBlockHeight,
                 lastError: state.lastError,
             });
             await sleep(retryDelayMs, signal);
@@ -442,27 +465,21 @@ async function downloadRemoteArchive(paths, manifest, state, progress, fetchImpl
         }
     }
 }
-async function fetchLatestManifest(fetchImpl, cacheBustEnd, signal) {
-    const url = cacheBustEnd === null
-        ? GETBLOCK_ARCHIVE_REMOTE_MANIFEST_URL
-        : `${GETBLOCK_ARCHIVE_REMOTE_MANIFEST_URL}?end=${cacheBustEnd}`;
-    const response = await fetchImpl(url, { signal });
+async function fetchManifestRange(fetchImpl, firstBlockHeight, lastBlockHeight, signal) {
+    const response = await fetchImpl(GETBLOCK_ARCHIVE_REMOTE_MANIFEST_URL, { signal });
+    if (response.status === 404) {
+        return null;
+    }
     if (!response.ok) {
         throw new Error(`managed_getblock_archive_manifest_http_${response.status}`);
     }
-    return assertManifestShape(await response.json());
-}
-export function resolveGetblockArchivePathsForTesting(dataDir) {
-    return resolvePaths(dataDir);
+    const manifest = assertAggregateManifestShape(await response.json());
+    return manifest.ranges.find((range) => range.firstBlockHeight === firstBlockHeight && range.lastBlockHeight === lastBlockHeight) ?? null;
 }
-export async function resolveReadyGetblockArchiveForTesting(dataDir) {
-    return resolveReadyLocalGetblockArchive(resolvePaths(dataDir));
+export function resolveGetblockArchivePathsForTesting(dataDir, firstBlockHeight = GETBLOCK_ARCHIVE_FIRST_HEIGHT, lastBlockHeight = GETBLOCK_ARCHIVE_BASE_HEIGHT + GETBLOCK_ARCHIVE_RANGE_SIZE) {
+    return resolvePaths(dataDir, firstBlockHeight, lastBlockHeight);
 }
-async function resolveReadyLocalGetblockArchive(paths, state = null) {
-    const manifest = await readManifest(paths.manifestPath).catch(() => null);
-    if (manifest === null) {
-        return null;
-    }
+async function resolveReadyLocalGetblockArchive(paths, manifest, state = null) {
     const info = await statOrNull(paths.artifactPath);
     if (info === null || info.size !== manifest.artifactSizeBytes) {
         return null;
@@ -472,7 +489,8 @@ async function resolveReadyLocalGetblockArchive(paths, state = null) {
         try {
             await validateWholeFile(paths.artifactPath, manifest);
             loadedState.formatVersion = manifest.formatVersion;
-            loadedState.endHeight = manifest.endHeight;
+            loadedState.firstBlockHeight = manifest.firstBlockHeight;
+            loadedState.lastBlockHeight = manifest.lastBlockHeight;
             loadedState.artifactSizeBytes = manifest.artifactSizeBytes;
             loadedState.artifactSha256 = manifest.artifactSha256;
             loadedState.chunkSizeBytes = manifest.chunkSizeBytes;
@@ -489,40 +507,71 @@ async function resolveReadyLocalGetblockArchive(paths, state = null) {
     return {
         manifest,
         artifactPath: paths.artifactPath,
-        manifestPath: paths.manifestPath,
     };
 }
-export async function prepareLatestGetblockArchive(options) {
-    const paths = resolvePaths(options.dataDir);
+export async function resolveReadyGetblockArchiveForTesting(dataDir, manifest) {
+    return resolveReadyLocalGetblockArchive(resolvePaths(dataDir, manifest.firstBlockHeight, manifest.lastBlockHeight), manifest);
+}
+export async function prepareGetblockArchiveRange(options) {
+    const paths = resolvePaths(options.dataDir, options.firstBlockHeight, options.lastBlockHeight);
     await mkdir(paths.directory, { recursive: true });
     const state = await loadState(paths);
-    const readyLocal = await resolveReadyLocalGetblockArchive(paths, state);
     const fetchImpl = options.fetchImpl ?? fetch;
     let remoteManifest;
     try {
-        remoteManifest = await fetchLatestManifest(fetchImpl, readyLocal?.manifest.endHeight ?? null, options.signal);
+        remoteManifest = await fetchManifestRange(fetchImpl, options.firstBlockHeight, options.lastBlockHeight, options.signal);
     }
     catch {
-        return readyLocal;
+        const readyLocal = {
+            formatVersion: state.formatVersion,
+            chain: "main",
+            baseSnapshotHeight: GETBLOCK_ARCHIVE_BASE_HEIGHT,
+            firstBlockHeight: state.firstBlockHeight ?? options.firstBlockHeight,
+            lastBlockHeight: state.lastBlockHeight ?? options.lastBlockHeight,
+            artifactFilename: buildRangeFilename(state.firstBlockHeight ?? options.firstBlockHeight, state.lastBlockHeight ?? options.lastBlockHeight),
+            artifactSizeBytes: state.artifactSizeBytes,
+            artifactSha256: state.artifactSha256 ?? "",
+            chunkSizeBytes: state.chunkSizeBytes,
+            chunkSha256s: [],
+        };
+        if (state.validated
+            && state.firstBlockHeight === options.firstBlockHeight
+            && state.lastBlockHeight === options.lastBlockHeight
+            && state.artifactSha256 !== null) {
+            const resolved = await resolveReadyLocalGetblockArchive(paths, readyLocal, state).catch(() => null);
+            if (resolved !== null) {
+                return resolved;
+            }
+        }
+        throw new Error("managed_getblock_archive_manifest_refresh_failed");
+    }
+    if (remoteManifest === null) {
+        return null;
     }
+    const readyLocal = await resolveReadyLocalGetblockArchive(paths, remoteManifest, state);
     if (readyLocal !== null
-        && readyLocal.manifest.endHeight === remoteManifest.endHeight
         && readyLocal.manifest.artifactSha256 === remoteManifest.artifactSha256) {
         return readyLocal;
     }
-    if (readyLocal !== null && readyLocal.manifest.endHeight > remoteManifest.endHeight) {
-        return readyLocal;
-    }
-    await writeJsonAtomic(paths.partialManifestPath, remoteManifest);
-    try {
-        await downloadRemoteArchive(paths, remoteManifest, state, options.progress, fetchImpl, options.signal);
-    }
-    catch {
-        return readyLocal;
-    }
-    return resolveReadyLocalGetblockArchive(paths, state);
+    await downloadRemoteArchive(paths, remoteManifest, state, options.progress, fetchImpl, options.signal);
+    return resolveReadyLocalGetblockArchive(paths, remoteManifest, state);
+}
+export async function deleteGetblockArchiveRange(options) {
+    const paths = resolvePaths(options.dataDir, options.firstBlockHeight, options.lastBlockHeight);
+    await rm(paths.artifactPath, { force: true }).catch(() => undefined);
+    await rm(paths.partialArtifactPath, { force: true }).catch(() => undefined);
+    await rm(paths.statePath, { force: true }).catch(() => undefined);
+}
+export async function prepareLatestGetblockArchive(options) {
+    return prepareGetblockArchiveRange({
+        ...options,
+        firstBlockHeight: GETBLOCK_ARCHIVE_FIRST_HEIGHT,
+        lastBlockHeight: GETBLOCK_ARCHIVE_BASE_HEIGHT + GETBLOCK_ARCHIVE_RANGE_SIZE,
+    });
 }
 export const prepareLatestGetblockArchiveForTesting = prepareLatestGetblockArchive;
+export const prepareGetblockArchiveRangeForTesting = prepareGetblockArchiveRange;
+export const deleteGetblockArchiveRangeForTesting = deleteGetblockArchiveRange;
 export async function waitForGetblockArchiveImportForTesting(rpc, progress, targetEndHeight, signal) {
     await waitForGetblockArchiveImport(rpc, progress, targetEndHeight, signal);
 }
@@ -533,7 +582,7 @@ export async function waitForGetblockArchiveImport(rpc, progress, targetEndHeigh
         }
         const info = await rpc.getBlockchainInfo();
         await progress.setPhase("getblock_archive_import", {
-            message: "Bitcoin Core is importing getblock archive blocks.",
+            message: "Bitcoin Core is importing getblock range blocks.",
             blocks: info.blocks,
             headers: info.headers,
             targetHeight: targetEndHeight,

package/dist/bitcoind/bootstrap.d.ts

@@ -1,7 +1,7 @@
 export { DEFAULT_SNAPSHOT_METADATA } from "./bootstrap/constants.js";
 export { AssumeUtxoBootstrapController } from "./bootstrap/controller.js";
 export { downloadSnapshotFileForTesting } from "./bootstrap/download.js";
-export { prepareLatestGetblockArchive, prepareLatestGetblockArchiveForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, waitForGetblockArchiveImport, waitForGetblockArchiveImportForTesting, } from "./bootstrap/getblock-archive.js";
+export { deleteGetblockArchiveRange, deleteGetblockArchiveRangeForTesting, prepareGetblockArchiveRange, prepareGetblockArchiveRangeForTesting, prepareLatestGetblockArchive, prepareLatestGetblockArchiveForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, waitForGetblockArchiveImport, waitForGetblockArchiveImportForTesting, } from "./bootstrap/getblock-archive.js";
 export { waitForHeadersForTesting } from "./bootstrap/headers.js";
 export { resolveBootstrapPathsForTesting } from "./bootstrap/paths.js";
 export { loadBootstrapStateForTesting, saveBootstrapStateForTesting, createBootstrapStateForTesting, } from "./bootstrap/state.js";

package/dist/bitcoind/bootstrap.js

@@ -1,7 +1,7 @@
 export { DEFAULT_SNAPSHOT_METADATA } from "./bootstrap/constants.js";
 export { AssumeUtxoBootstrapController } from "./bootstrap/controller.js";
 export { downloadSnapshotFileForTesting } from "./bootstrap/download.js";
-export { prepareLatestGetblockArchive, prepareLatestGetblockArchiveForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, waitForGetblockArchiveImport, waitForGetblockArchiveImportForTesting, } from "./bootstrap/getblock-archive.js";
+export { deleteGetblockArchiveRange, deleteGetblockArchiveRangeForTesting, prepareGetblockArchiveRange, prepareGetblockArchiveRangeForTesting, prepareLatestGetblockArchive, prepareLatestGetblockArchiveForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, waitForGetblockArchiveImport, waitForGetblockArchiveImportForTesting, } from "./bootstrap/getblock-archive.js";
 export { waitForHeadersForTesting } from "./bootstrap/headers.js";
 export { resolveBootstrapPathsForTesting } from "./bootstrap/paths.js";
 export { loadBootstrapStateForTesting, saveBootstrapStateForTesting, createBootstrapStateForTesting, } from "./bootstrap/state.js";

package/dist/bitcoind/client/factory.js

@@ -1,12 +1,12 @@
 import { loadBundledGenesisParameters } from "@cogcoin/indexer";
 import { resolveDefaultBitcoindDataDirForTesting } from "../../app-paths.js";
 import { openClient } from "../../client.js";
-import { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, } from "../bootstrap.js";
+import { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting, } from "../bootstrap.js";
 import { attachOrStartIndexerDaemon } from "../indexer-daemon.js";
 import { createRpcClient } from "../node.js";
 import { assertCogcoinProcessingStartHeight, resolveCogcoinProcessingStartHeight, } from "../processing-start-height.js";
 import { ManagedProgressController } from "../progress.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService, } from "../service.js";
+import { attachOrStartManagedBitcoindService, } from "../service.js";
 import { DefaultManagedBitcoindClient } from "./managed-client.js";
 const DEFAULT_SYNC_DEBOUNCE_MS = 250;
 async function createManagedBitcoindClient(options) {
@@ -27,52 +27,17 @@ async function createManagedBitcoindClient(options) {
     try {
         await progress.start();
         progressStarted = true;
-        let getblockArchive = options.chain === "main"
-            ? await prepareLatestGetblockArchiveForTesting({
-                dataDir,
-                progress,
-                fetchImpl: options.fetchImpl,
-            })
-            : null;
-        if (options.chain === "main" && getblockArchive !== null) {
-            const existingProbe = await probeManagedBitcoindService({
-                ...options,
-                dataDir,
-            });
-            if (existingProbe.compatibility === "compatible" && existingProbe.status !== null) {
-                const currentArchiveEndHeight = existingProbe.status.getblockArchiveEndHeight ?? null;
-                const currentArchiveSha256 = existingProbe.status.getblockArchiveSha256 ?? null;
-                const nextArchiveEndHeight = getblockArchive.manifest.endHeight;
-                const nextArchiveSha256 = getblockArchive.manifest.artifactSha256;
-                const needsRestart = currentArchiveEndHeight !== nextArchiveEndHeight
-                    || currentArchiveSha256 !== nextArchiveSha256;
-                if (needsRestart) {
-                    const restartApproved = options.confirmGetblockArchiveRestart === undefined
-                        ? false
-                        : await options.confirmGetblockArchiveRestart({
-                            currentArchiveEndHeight,
-                            nextArchiveEndHeight,
-                        });
-                    if (restartApproved) {
-                        await stopManagedBitcoindService({
-                            dataDir,
-                            walletRootId: options.walletRootId,
-                            shutdownTimeoutMs: options.shutdownTimeoutMs,
-                        });
-                    }
-                    else {
-                        getblockArchive = null;
-                    }
-                }
-            }
-        }
         const node = await attachOrStartManagedBitcoindService({
             ...options,
             dataDir,
-            getblockArchivePath: getblockArchive?.artifactPath ?? null,
-            getblockArchiveEndHeight: getblockArchive?.manifest.endHeight ?? null,
-            getblockArchiveSha256: getblockArchive?.manifest.artifactSha256 ?? null,
+            getblockArchivePath: null,
+            getblockArchiveEndHeight: null,
+            getblockArchiveSha256: null,
         });
+        const walletRootId = options.walletRootId ?? node.walletRootId;
+        if (walletRootId === undefined) {
+            throw new Error("managed_bitcoind_wallet_root_unavailable");
+        }
         const rpc = createRpcClient(node.rpc);
         const bootstrap = new AssumeUtxoBootstrapController({
             rpc,
@@ -105,7 +70,7 @@ async function createManagedBitcoindClient(options) {
                 walletRootId: options.walletRootId,
                 startupTimeoutMs: options.startupTimeoutMs,
             })
-            : null, options.startHeight, options.syncDebounceMs ?? DEFAULT_SYNC_DEBOUNCE_MS);
+            : null, options.startHeight, options.syncDebounceMs ?? DEFAULT_SYNC_DEBOUNCE_MS, dataDir, walletRootId, options.startupTimeoutMs, options.shutdownTimeoutMs, options.fetchImpl);
     }
     catch (error) {
         if (progressStarted) {

package/dist/bitcoind/client/follow-loop.js

@@ -54,7 +54,7 @@ export function scheduleSync(dependencies) {
     }
     const timer = setTimeout(() => {
         dependencies.setDebounceTimer(null);
-        void dependencies.syncToTip();
+        void dependencies.syncToTip().catch(() => undefined);
     }, dependencies.syncDebounceMs);
     dependencies.setDebounceTimer(timer);
 }

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

@@ -21,6 +21,7 @@ export interface SyncEngineDependencies {
     progress: ManagedProgressController;
     bootstrap: AssumeUtxoBootstrapController;
     startHeight: number;
+    targetHeightCap?: number | null;
     bitcoinRateTracker: BlockRateTracker;
     cogcoinRateTracker: BlockRateTracker;
     abortSignal?: AbortSignal;

package/dist/bitcoind/client/managed-client.d.ts

@@ -1,13 +1,13 @@
 import type { BitcoinBlock } from "@cogcoin/indexer/types";
 import type { Client, ClientStoreAdapter } from "../../types.js";
-import type { AssumeUtxoBootstrapController } from "../bootstrap.js";
+import { AssumeUtxoBootstrapController } from "../bootstrap.js";
 import type { IndexerDaemonClient } from "../indexer-daemon.js";
 import type { ManagedProgressController } from "../progress.js";
 import type { BitcoinRpcClient } from "../rpc.js";
 import type { ManagedBitcoindClient, ManagedBitcoindNodeHandle, ManagedBitcoindStatus, SyncResult } from "../types.js";
 export declare class DefaultManagedBitcoindClient implements ManagedBitcoindClient {
     #private;
-    constructor(client: Client, store: ClientStoreAdapter, node: ManagedBitcoindNodeHandle, rpc: BitcoinRpcClient, progress: ManagedProgressController, bootstrap: AssumeUtxoBootstrapController, indexerDaemon: IndexerDaemonClient | null, reattachIndexerDaemon: (() => Promise<IndexerDaemonClient | null>) | null, startHeight: number, syncDebounceMs: number);
+    constructor(client: Client, store: ClientStoreAdapter, node: ManagedBitcoindNodeHandle, rpc: BitcoinRpcClient, progress: ManagedProgressController, bootstrap: AssumeUtxoBootstrapController, indexerDaemon: IndexerDaemonClient | null, reattachIndexerDaemon: (() => Promise<IndexerDaemonClient | null>) | null, startHeight: number, syncDebounceMs: number, dataDir: string, walletRootId: string, startupTimeoutMs: number | undefined, shutdownTimeoutMs: number | undefined, fetchImpl: typeof fetch | undefined);
     getTip(): Promise<import("../../types.js").ClientTip | null>;
     getState(): Promise<import("@cogcoin/indexer/types").IndexerState>;
     applyBlock(block: BitcoinBlock): Promise<import("../../types.js").ApplyBlockResult>;