@cogcoin/client 0.5.6 → 0.5.7

package/dist/bitcoind/progress/render-policy.js

@@ -0,0 +1,81 @@
+import { HEADLESS_PROGRESS_TICK_MS, PROGRESS_TICK_MS } from "./constants.js";
+export const DEFAULT_RENDER_CLOCK = {
+    now: () => Date.now(),
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+};
+export function resolveTtyRenderPolicy(progressOutput, stream, options = {}) {
+    const ttyActive = stream.isTTY === true;
+    const enabled = progressOutput === "none"
+        ? false
+        : progressOutput === "tty"
+            ? true
+            : ttyActive;
+    const env = options.env ?? process.env;
+    const linuxHeadlessThrottle = enabled
+        && ttyActive
+        && (options.platform ?? process.platform) === "linux"
+        && (env.DISPLAY?.trim() ?? "").length === 0
+        && (env.WAYLAND_DISPLAY?.trim() ?? "").length === 0;
+    return {
+        enabled,
+        linuxHeadlessThrottle,
+        repaintIntervalMs: linuxHeadlessThrottle ? HEADLESS_PROGRESS_TICK_MS : PROGRESS_TICK_MS,
+    };
+}
+export class TtyRenderThrottle {
+    #clock;
+    #intervalMs;
+    #onRender;
+    #throttled;
+    #lastRenderAt = null;
+    #pendingTimer = null;
+    constructor(options) {
+        this.#clock = options.clock ?? DEFAULT_RENDER_CLOCK;
+        this.#intervalMs = options.intervalMs;
+        this.#onRender = options.onRender;
+        this.#throttled = options.throttled;
+    }
+    request() {
+        if (!this.#throttled) {
+            this.cancel();
+            this.#renderNow();
+            return;
+        }
+        const now = this.#clock.now();
+        if (this.#lastRenderAt === null || (now - this.#lastRenderAt) >= this.#intervalMs) {
+            this.cancel();
+            this.#renderNow();
+            return;
+        }
+        if (this.#pendingTimer !== null) {
+            return;
+        }
+        const delayMs = Math.max(0, this.#intervalMs - (now - this.#lastRenderAt));
+        this.#pendingTimer = this.#clock.setTimeout(() => {
+            this.#pendingTimer = null;
+            this.#renderNow();
+        }, delayMs);
+    }
+    flush() {
+        if (this.#pendingTimer === null) {
+            return;
+        }
+        this.#clock.clearTimeout(this.#pendingTimer);
+        this.#pendingTimer = null;
+        this.#renderNow();
+    }
+    cancel() {
+        if (this.#pendingTimer === null) {
+            return;
+        }
+        this.#clock.clearTimeout(this.#pendingTimer);
+        this.#pendingTimer = null;
+    }
+    #renderNow() {
+        this.#lastRenderAt = this.#clock.now();
+        this.#onRender();
+    }
+}

package/dist/bitcoind/service-paths.js

@@ -3,9 +3,6 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { resolveCogcoinPathsForTesting, resolveDefaultBitcoindDataDirForTesting } from "../app-paths.js";
 export const UNINITIALIZED_WALLET_ROOT_ID = "wallet-root-uninitialized";
-function sanitizeWalletRootId(walletRootId) {
-    return walletRootId.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
 function createDataDirSuffix(dataDir) {
     return createHash("sha256").update(dataDir).digest("hex").slice(0, 12);
 }
@@ -17,7 +14,6 @@ function resolveIndexerDaemonSocketPath(serviceRootId) {
     return join(tmpdir(), `cogcoin-indexer-${socketId}.sock`);
 }
 export function resolveManagedServicePaths(dataDir, walletRootId = UNINITIALIZED_WALLET_ROOT_ID) {
-    const normalizedWalletRootId = sanitizeWalletRootId(walletRootId);
     const defaultPaths = resolveCogcoinPathsForTesting();
     const defaultBitcoindDataDir = resolveDefaultBitcoindDataDirForTesting();
     const useDefaultRoots = dataDir === defaultBitcoindDataDir;
@@ -25,8 +21,8 @@ export function resolveManagedServicePaths(dataDir, walletRootId = UNINITIALIZED
     const runtimeRoot = useDefaultRoots ? defaultPaths.runtimeRoot : join(dataRoot, "runtime");
     const indexerRoot = useDefaultRoots ? defaultPaths.indexerRoot : join(dataRoot, "indexer");
     const serviceRootId = useDefaultRoots
-        ? normalizedWalletRootId
-        : `${normalizedWalletRootId}-${createDataDirSuffix(dataDir)}`;
+        ? "managed"
+        : `managed-${createDataDirSuffix(dataDir)}`;
     const walletRuntimeRoot = join(runtimeRoot, serviceRootId);
     const indexerServiceRoot = join(indexerRoot, serviceRootId);
     return {

package/dist/bitcoind/service.d.ts

@@ -20,7 +20,11 @@ interface ManagedWalletReplicaRpc {
     }>;
     walletLock(walletName: string): Promise<null>;
 }
-type ManagedBitcoindServiceOptions = Pick<InternalManagedBitcoindOptions, "dataDir" | "chain" | "startHeight" | "walletRootId" | "rpcPort" | "zmqPort" | "p2pPort" | "pollIntervalMs" | "startupTimeoutMs" | "shutdownTimeoutMs" | "managedWalletPassphrase">;
+type ManagedBitcoindServiceOptions = Pick<InternalManagedBitcoindOptions, "dataDir" | "chain" | "startHeight" | "walletRootId" | "rpcPort" | "zmqPort" | "p2pPort" | "pollIntervalMs" | "startupTimeoutMs" | "shutdownTimeoutMs" | "managedWalletPassphrase"> & {
+    getblockArchivePath?: string | null;
+    getblockArchiveEndHeight?: number | null;
+    getblockArchiveSha256?: string | null;
+};
 export type ManagedBitcoindServiceCompatibility = "compatible" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch" | "unreachable" | "protocol-error";
 export interface ManagedBitcoindServiceProbeResult {
     compatibility: ManagedBitcoindServiceCompatibility;

package/dist/bitcoind/service.js

@@ -226,15 +226,14 @@ async function waitForRpcReady(rpc, cookieFile, expectedChain, timeoutMs) {
     throw lastError instanceof Error ? lastError : new Error("bitcoind_rpc_timeout");
 }
 function validateManagedBitcoindStatus(status, options, runtimeRoot) {
+    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
+    const legacyRuntimeRoot = join(resolveManagedServicePaths(options.dataDir ?? "", walletRootId).runtimeRoot, walletRootId);
     if (status.serviceApiVersion !== MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE) {
         throw new Error("managed_bitcoind_service_version_mismatch");
     }
-    if (status.walletRootId !== (options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID)) {
-        throw new Error("managed_bitcoind_wallet_root_mismatch");
-    }
     if (status.chain !== options.chain
         || status.dataDir !== (options.dataDir ?? "")
-        || status.runtimeRoot !== runtimeRoot) {
+        || (status.runtimeRoot !== runtimeRoot && status.runtimeRoot !== legacyRuntimeRoot)) {
         throw new Error("managed_bitcoind_runtime_mismatch");
     }
 }
@@ -275,6 +274,8 @@ function createBitcoindServiceStatus(options) {
         rpc: options.rpc,
         zmq: options.zmq,
         p2pPort: options.p2pPort,
+        getblockArchiveEndHeight: options.getblockArchiveEndHeight,
+        getblockArchiveSha256: options.getblockArchiveSha256,
         walletReplica: options.walletReplica,
         startedAtUnixMs: options.startedAtUnixMs,
         heartbeatAtUnixMs: options.heartbeatAtUnixMs,
@@ -287,9 +288,7 @@ function mapManagedBitcoindValidationError(error) {
         compatibility: error instanceof Error
             ? error.message === "managed_bitcoind_service_version_mismatch"
                 ? "service-version-mismatch"
-                : error.message === "managed_bitcoind_wallet_root_mismatch"
-                    ? "wallet-root-mismatch"
-                    : "runtime-mismatch"
+                : "runtime-mismatch"
             : "protocol-error",
         status: null,
         error: error instanceof Error ? error.message : "managed_bitcoind_protocol_error",
@@ -366,6 +365,8 @@ async function resolveRuntimeConfig(statusPath, configPath, options) {
         zmqPort,
         p2pPort,
         dbcacheMiB: detectManagedBitcoindDbcacheMiB(),
+        getblockArchiveEndHeight: options.getblockArchiveEndHeight ?? null,
+        getblockArchiveSha256: options.getblockArchiveSha256 ?? null,
     };
 }
 async function writeBitcoinConf(filePath, options, runtimeConfig) {
@@ -407,6 +408,9 @@ function buildManagedServiceArgs(options, runtimeConfig) {
     if (options.chain === "regtest") {
         args.push("-chain=regtest");
     }
+    if (options.getblockArchivePath !== undefined && options.getblockArchivePath !== null) {
+        args.push(`-loadblock=${options.getblockArchivePath}`);
+    }
     return args;
 }
 export async function writeBitcoinConfForTesting(filePath, options, runtimeConfig) {
@@ -547,6 +551,8 @@ async function writeBitcoindStatus(paths, status) {
         rpc: status.rpc,
         zmqPort: status.zmq.port,
         p2pPort: status.p2pPort,
+        getblockArchiveEndHeight: status.getblockArchiveEndHeight,
+        getblockArchiveSha256: status.getblockArchiveSha256,
     });
 }
 async function clearManagedBitcoindRuntimeArtifacts(paths) {
@@ -590,6 +596,11 @@ export async function stopManagedBitcoindServiceWithLockHeld(options) {
 }
 export async function withClaimedUninitializedManagedRuntime(options, callback) {
     const targetWalletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
+    const targetPaths = resolveManagedServicePaths(options.dataDir, targetWalletRootId);
+    const uninitializedPaths = resolveManagedServicePaths(options.dataDir, UNINITIALIZED_WALLET_ROOT_ID);
+    if (targetPaths.walletRuntimeRoot === uninitializedPaths.walletRuntimeRoot) {
+        return callback();
+    }
     if (targetWalletRootId === UNINITIALIZED_WALLET_ROOT_ID) {
         return callback();
     }
@@ -598,7 +609,6 @@ export async function withClaimedUninitializedManagedRuntime(options, callback)
         return callback();
     }
     claimedUninitializedRuntimeKeys.add(claimKey);
-    const uninitializedPaths = resolveManagedServicePaths(options.dataDir, UNINITIALIZED_WALLET_ROOT_ID);
     const lockTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
     const bitcoindLock = await acquireFileLockWithRetry(uninitializedPaths.bitcoindLockPath, {
         purpose: "managed-bitcoind-claim-uninitialized",
@@ -638,12 +648,15 @@ export async function withClaimedUninitializedManagedRuntime(options, callback)
 async function refreshManagedBitcoindStatus(status, paths, options) {
     const nowUnixMs = Date.now();
     const rpc = createRpcClient(status.rpc);
+    const targetWalletRootId = options.walletRootId ?? status.walletRootId;
     try {
         await waitForRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS);
         await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint);
-        const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, status.walletRootId, status.dataDir);
+        const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, targetWalletRootId, status.dataDir);
         const nextStatus = {
             ...status,
+            walletRootId: targetWalletRootId,
+            runtimeRoot: paths.walletRuntimeRoot,
             state: "ready",
             processId: await isProcessAlive(status.processId) ? status.processId : null,
             walletReplica,
@@ -657,6 +670,8 @@ async function refreshManagedBitcoindStatus(status, paths, options) {
     catch (error) {
         const nextStatus = {
             ...status,
+            walletRootId: targetWalletRootId,
+            runtimeRoot: paths.walletRuntimeRoot,
             state: "failed",
             processId: await isProcessAlive(status.processId) ? status.processId : null,
             heartbeatAtUnixMs: nowUnixMs,
@@ -677,6 +692,8 @@ function createNodeHandle(status, paths, options) {
         expectedChain: currentStatus.chain,
         startHeight: currentStatus.startHeight,
         dataDir: currentStatus.dataDir,
+        getblockArchiveEndHeight: currentStatus.getblockArchiveEndHeight ?? null,
+        getblockArchiveSha256: currentStatus.getblockArchiveSha256 ?? null,
         walletRootId: currentStatus.walletRootId,
         runtimeRoot: paths.walletRuntimeRoot,
         async validate() {
@@ -684,6 +701,9 @@ function createNodeHandle(status, paths, options) {
         },
         async refreshServiceStatus() {
             currentStatus = await refreshManagedBitcoindStatus(currentStatus, paths, options);
+            this.getblockArchiveEndHeight = currentStatus.getblockArchiveEndHeight ?? null;
+            this.getblockArchiveSha256 = currentStatus.getblockArchiveSha256 ?? null;
+            this.walletRootId = currentStatus.walletRootId;
             return currentStatus;
         },
         async stop() {
@@ -786,57 +806,76 @@ export async function attachOrStartManagedBitcoindService(options) {
                 await verifyBitcoindVersion(bitcoindPath);
                 const binaryVersion = SUPPORTED_BITCOIND_VERSION;
                 await mkdir(resolvedOptions.dataDir ?? "", { recursive: true });
-                const runtimeConfig = await resolveRuntimeConfig(paths.bitcoindStatusPath, paths.bitcoindRuntimeConfigPath, resolvedOptions);
-                await writeBitcoinConf(paths.bitcoinConfPath, resolvedOptions, runtimeConfig);
-                const rpcConfig = runtimeConfig.rpc;
-                const zmqConfig = {
-                    endpoint: `tcp://${LOCAL_HOST}:${runtimeConfig.zmqPort}`,
-                    topic: "hashblock",
-                    port: runtimeConfig.zmqPort,
-                    pollIntervalMs: resolvedOptions.pollIntervalMs ?? 15_000,
+                const startManagedProcess = async (startOptions) => {
+                    const runtimeConfig = await resolveRuntimeConfig(paths.bitcoindStatusPath, paths.bitcoindRuntimeConfigPath, startOptions);
+                    await writeBitcoinConf(paths.bitcoinConfPath, startOptions, runtimeConfig);
+                    const rpcConfig = runtimeConfig.rpc;
+                    const zmqConfig = {
+                        endpoint: `tcp://${LOCAL_HOST}:${runtimeConfig.zmqPort}`,
+                        topic: "hashblock",
+                        port: runtimeConfig.zmqPort,
+                        pollIntervalMs: startOptions.pollIntervalMs ?? 15_000,
+                    };
+                    const child = spawn(bitcoindPath, buildManagedServiceArgs(startOptions, runtimeConfig), {
+                        detached: true,
+                        stdio: "ignore",
+                    });
+                    child.unref();
+                    const rpc = createRpcClient(rpcConfig);
+                    try {
+                        await waitForRpcReady(rpc, rpcConfig.cookieFile, startOptions.chain, startupTimeoutMs);
+                        await validateNodeConfigForTesting(rpc, startOptions.chain, zmqConfig.endpoint);
+                    }
+                    catch (error) {
+                        if (child.pid !== undefined) {
+                            try {
+                                process.kill(child.pid, "SIGTERM");
+                            }
+                            catch {
+                                // ignore kill failures during startup cleanup
+                            }
+                        }
+                        throw error;
+                    }
+                    const nowUnixMs = Date.now();
+                    const walletRootId = startOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
+                    const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, walletRootId, startOptions.dataDir ?? "");
+                    return createBitcoindServiceStatus({
+                        binaryVersion,
+                        serviceInstanceId: randomBytes(16).toString("hex"),
+                        state: "ready",
+                        processId: child.pid ?? null,
+                        walletRootId,
+                        chain: startOptions.chain,
+                        dataDir: startOptions.dataDir ?? "",
+                        runtimeRoot: paths.walletRuntimeRoot,
+                        startHeight: startOptions.startHeight,
+                        rpc: rpcConfig,
+                        zmq: zmqConfig,
+                        p2pPort: runtimeConfig.p2pPort,
+                        getblockArchiveEndHeight: runtimeConfig.getblockArchiveEndHeight ?? null,
+                        getblockArchiveSha256: runtimeConfig.getblockArchiveSha256 ?? null,
+                        walletReplica,
+                        startedAtUnixMs: nowUnixMs,
+                        heartbeatAtUnixMs: nowUnixMs,
+                        lastError: walletReplica.message ?? null,
+                    });
                 };
-                const child = spawn(bitcoindPath, buildManagedServiceArgs(resolvedOptions, runtimeConfig), {
-                    detached: true,
-                    stdio: "ignore",
-                });
-                child.unref();
-                const rpc = createRpcClient(rpcConfig);
+                let status;
                 try {
-                    await waitForRpcReady(rpc, rpcConfig.cookieFile, resolvedOptions.chain, startupTimeoutMs);
-                    await validateNodeConfigForTesting(rpc, resolvedOptions.chain, zmqConfig.endpoint);
+                    status = await startManagedProcess(resolvedOptions);
                 }
                 catch (error) {
-                    if (child.pid !== undefined) {
-                        try {
-                            process.kill(child.pid, "SIGTERM");
-                        }
-                        catch {
-                            // ignore kill failures during startup cleanup
-                        }
+                    if (resolvedOptions.getblockArchivePath === undefined || resolvedOptions.getblockArchivePath === null) {
+                        throw error;
                     }
-                    throw error;
+                    status = await startManagedProcess({
+                        ...resolvedOptions,
+                        getblockArchivePath: null,
+                        getblockArchiveEndHeight: null,
+                        getblockArchiveSha256: null,
+                    });
                 }
-                const nowUnixMs = Date.now();
-                const walletRootId = resolvedOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-                const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, walletRootId, resolvedOptions.dataDir ?? "");
-                const status = createBitcoindServiceStatus({
-                    binaryVersion,
-                    serviceInstanceId: randomBytes(16).toString("hex"),
-                    state: "ready",
-                    processId: child.pid ?? null,
-                    walletRootId,
-                    chain: resolvedOptions.chain,
-                    dataDir: resolvedOptions.dataDir ?? "",
-                    runtimeRoot: paths.walletRuntimeRoot,
-                    startHeight: resolvedOptions.startHeight,
-                    rpc: rpcConfig,
-                    zmq: zmqConfig,
-                    p2pPort: runtimeConfig.p2pPort,
-                    walletReplica,
-                    startedAtUnixMs: nowUnixMs,
-                    heartbeatAtUnixMs: nowUnixMs,
-                    lastError: walletReplica.message ?? null,
-                });
                 await writeBitcoindStatus(paths, status);
                 return createNodeHandle(status, paths, resolvedOptions);
             }

package/dist/bitcoind/testing.d.ts

@@ -3,7 +3,7 @@ export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopInde
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
 export { attachOrStartManagedBitcoindService, buildManagedServiceArgsForTesting, readManagedBitcoindServiceStatusForTesting, resolveManagedBitcoindDbcacheMiB, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, writeBitcoinConfForTesting, } from "./service.js";
-export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, resolveBootstrapPathsForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
+export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
 export { buildBitcoindArgsForTesting, createRpcClient, launchManagedBitcoindNode, resolveDefaultBitcoindDataDirForTesting, validateNodeConfigForTesting, } from "./node.js";
 export { ManagedProgressController, TtyProgressRenderer, advanceFollowSceneStateForTesting, createFollowSceneStateForTesting, createBootstrapProgressForTesting, formatCompactFollowAgeLabelForTesting, loadBannerArtForTesting, loadScrollArtForTesting, loadTrainCarArtForTesting, loadTrainArtForTesting, loadTrainSmokeArtForTesting, formatProgressLineForTesting, formatQuoteLineForTesting, renderArtFrameForTesting, renderCompletionFrameForTesting, renderFollowFrameForTesting, renderIntroFrameForTesting, resolveCompletionMessageForTesting, resolveIntroMessageForTesting, resolveStatusFieldTextForTesting, setFollowBlockTimeForTesting, setFollowBlockTimesForTesting, syncFollowSceneStateForTesting, } from "./progress.js";
 export { WritingQuoteRotator, loadWritingQuotesForTesting, shuffleIndicesForTesting, } from "./quotes.js";

package/dist/bitcoind/testing.js

@@ -3,7 +3,7 @@ export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopInde
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
 export { attachOrStartManagedBitcoindService, buildManagedServiceArgsForTesting, readManagedBitcoindServiceStatusForTesting, resolveManagedBitcoindDbcacheMiB, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, writeBitcoinConfForTesting, } from "./service.js";
-export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, resolveBootstrapPathsForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
+export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
 export { buildBitcoindArgsForTesting, createRpcClient, launchManagedBitcoindNode, resolveDefaultBitcoindDataDirForTesting, validateNodeConfigForTesting, } from "./node.js";
 export { ManagedProgressController, TtyProgressRenderer, advanceFollowSceneStateForTesting, createFollowSceneStateForTesting, createBootstrapProgressForTesting, formatCompactFollowAgeLabelForTesting, loadBannerArtForTesting, loadScrollArtForTesting, loadTrainCarArtForTesting, loadTrainArtForTesting, loadTrainSmokeArtForTesting, formatProgressLineForTesting, formatQuoteLineForTesting, renderArtFrameForTesting, renderCompletionFrameForTesting, renderFollowFrameForTesting, renderIntroFrameForTesting, resolveCompletionMessageForTesting, resolveIntroMessageForTesting, resolveStatusFieldTextForTesting, setFollowBlockTimeForTesting, setFollowBlockTimesForTesting, syncFollowSceneStateForTesting, } from "./progress.js";
 export { WritingQuoteRotator, loadWritingQuotesForTesting, shuffleIndicesForTesting, } from "./quotes.js";

package/dist/bitcoind/types.d.ts

@@ -1,5 +1,5 @@
 import type { BitcoinBlock, Client, ClientOptions, ClientTip } from "../types.js";
-export type BootstrapPhase = "snapshot_download" | "wait_headers_for_snapshot" | "load_snapshot" | "bitcoin_sync" | "cogcoin_sync" | "follow_tip" | "paused" | "error" | "complete";
+export type BootstrapPhase = "getblock_archive_download" | "getblock_archive_import" | "snapshot_download" | "wait_headers_for_snapshot" | "load_snapshot" | "bitcoin_sync" | "cogcoin_sync" | "follow_tip" | "paused" | "error" | "complete";
 export type ProgressOutputMode = "auto" | "tty" | "none";
 export interface SnapshotMetadata {
     url: string;
@@ -17,6 +17,28 @@ export interface SnapshotChunkManifest {
     snapshotSha256: string;
     chunkSha256s: string[];
 }
+export interface GetblockArchiveManifestBlockRecord {
+    height: number;
+    blockHash: string;
+    previousBlockHash: string;
+    recordOffset: number;
+    recordLength: number;
+    rawBlockSizeBytes: number;
+}
+export interface GetblockArchiveManifest {
+    formatVersion: number;
+    chain: "main";
+    baseSnapshotHeight: number;
+    firstBlockHeight: number;
+    endHeight: number;
+    blockCount: number;
+    artifactFilename: string;
+    artifactSizeBytes: number;
+    artifactSha256: string;
+    chunkSizeBytes: number;
+    chunkSha256s: string[];
+    blocks: GetblockArchiveManifestBlockRecord[];
+}
 export interface WritingQuote {
     quote: string;
     author: string;
@@ -63,6 +85,8 @@ export interface ManagedBitcoindRuntimeConfig {
     zmqPort: number;
     p2pPort: number;
     dbcacheMiB: number;
+    getblockArchiveEndHeight?: number | null;
+    getblockArchiveSha256?: string | null;
 }
 export declare const MANAGED_BITCOIND_SERVICE_API_VERSION = "cogcoin/bitcoind-service/v1";
 export type ManagedBitcoindServiceState = "starting" | "ready" | "stopping" | "failed";
@@ -81,6 +105,8 @@ export interface ManagedBitcoindServiceStatus {
     rpc: BitcoindRpcConfig;
     zmq: BitcoindZmqConfig;
     p2pPort: number;
+    getblockArchiveEndHeight: number | null;
+    getblockArchiveSha256: string | null;
     walletReplica: ManagedCoreWalletReplicaStatus | null;
     startedAtUnixMs: number;
     heartbeatAtUnixMs: number;
@@ -123,6 +149,10 @@ export interface ManagedBitcoindStatus {
     serviceStatus?: ManagedBitcoindObservedStatus | null;
     indexerDaemon?: ManagedIndexerDaemonObservedStatus | null;
 }
+export interface ManagedGetblockArchiveRestartRequest {
+    currentArchiveEndHeight: number | null;
+    nextArchiveEndHeight: number;
+}
 export interface ManagedBitcoindOptions extends ClientOptions {
     dataDir?: string;
     databasePath?: string;
@@ -137,6 +167,8 @@ export interface ManagedBitcoindOptions extends ClientOptions {
     managedWalletPassphrase?: string;
     onProgress?: (event: ManagedBitcoindProgressEvent) => void;
     progressOutput?: ProgressOutputMode;
+    fetchImpl?: typeof fetch;
+    confirmGetblockArchiveRestart?: (request: ManagedGetblockArchiveRestartRequest) => Promise<boolean>;
 }
 export interface ManagedBitcoindClient extends Client {
     syncToTip(): Promise<SyncResult>;
@@ -397,6 +429,8 @@ export interface ManagedBitcoindNodeHandle {
     expectedChain: "main" | "regtest";
     startHeight: number;
     dataDir: string;
+    getblockArchiveEndHeight: number | null;
+    getblockArchiveSha256: string | null;
     walletRootId?: string;
     runtimeRoot?: string;
     validate(): Promise<void>;

package/dist/cli/commands/follow.js

@@ -3,6 +3,7 @@ import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolut
 import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher } from "../signals.js";
+import { confirmGetblockArchiveRestart } from "./getblock-archive-restart.js";
 export async function runFollowCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
@@ -23,6 +24,7 @@ export async function runFollowCommand(parsed, context) {
             dataDir,
             walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
+            confirmGetblockArchiveRestart: async (options) => confirmGetblockArchiveRestart(parsed, context, options),
         });
         storeOwned = false;
         const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);

package/dist/cli/commands/getblock-archive-restart.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function confirmGetblockArchiveRestart(parsed: ParsedCliArgs, context: RequiredCliRunnerContext, options: {
+    currentArchiveEndHeight: number | null;
+    nextArchiveEndHeight: number;
+}): Promise<boolean>;

package/dist/cli/commands/getblock-archive-restart.js

@@ -0,0 +1,15 @@
+export async function confirmGetblockArchiveRestart(parsed, context, options) {
+    if (parsed.assumeYes) {
+        return true;
+    }
+    const prompter = context.createPrompter();
+    if (!prompter.isInteractive) {
+        return false;
+    }
+    const currentLabel = options.currentArchiveEndHeight === null
+        ? "without a getblock archive"
+        : `with a getblock archive through height ${options.currentArchiveEndHeight.toLocaleString()}`;
+    prompter.writeLine(`Managed bitcoind is already running ${currentLabel}. A newer getblock archive through height ${options.nextArchiveEndHeight.toLocaleString()} is available.`);
+    const answer = (await prompter.prompt(`Restart managed bitcoind to load the getblock archive through height ${options.nextArchiveEndHeight.toLocaleString()}? [y/N]: `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+}

package/dist/cli/commands/mining-admin.js

@@ -12,11 +12,13 @@ function createCommandPrompter(parsed, context) {
 export async function runMiningAdminCommand(parsed, context) {
     try {
         const provider = context.walletSecretProvider;
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         if (parsed.command === "hooks-mining-enable") {
             const prompter = createCommandPrompter(parsed, context);
             const view = await context.enableMiningHooks({
                 provider,
                 prompter,
+                paths: runtimePaths,
             });
             const nextSteps = getHooksEnableMiningNextSteps();
             if (parsed.outputMode === "preview-json") {
@@ -40,6 +42,7 @@ export async function runMiningAdminCommand(parsed, context) {
         if (parsed.command === "hooks-mining-disable") {
             const view = await context.disableMiningHooks({
                 provider,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "preview-json") {
                 writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "disabled", buildHooksPreviewData("hooks-disable-mining", view)));
@@ -57,6 +60,7 @@ export async function runMiningAdminCommand(parsed, context) {
             const view = await context.setupBuiltInMining({
                 provider,
                 prompter,
+                paths: runtimePaths,
             });
             const nextSteps = getMineSetupNextSteps();
             if (parsed.outputMode === "preview-json") {

package/dist/cli/commands/mining-read.js

@@ -5,9 +5,7 @@ import { writeLine } from "../io.js";
 import { inspectWalletLocalState } from "../../wallet/read/index.js";
 import { createErrorEnvelope, createSuccessEnvelope, describeCanonicalCommand, normalizeListPage, writeJsonValue, } from "../output.js";
 import { buildHooksStatusJson, buildMineLogJson, buildMineStatusJson } from "../read-json.js";
-import { resolveWalletRuntimePathsForTesting } from "../../wallet/runtime.js";
-async function readRotationIndices() {
-    const paths = resolveWalletRuntimePathsForTesting();
+async function readRotationIndices(paths) {
     const rotation = [];
     for (let index = 1; index <= 4; index += 1) {
         try {
@@ -26,10 +24,12 @@ export async function runMiningReadCommand(parsed, context) {
     try {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "hooks-mining-status") {
             const localState = await inspectWalletLocalState({
                 secretProvider: context.walletSecretProvider,
+                paths: runtimePaths,
             });
             const view = await context.inspectMiningControlPlane({
                 provider: context.walletSecretProvider,
@@ -52,6 +52,7 @@ export async function runMiningReadCommand(parsed, context) {
                     openedAtUnixMs: null,
                 },
                 verify: parsed.verify,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "json") {
                 const result = buildHooksStatusJson(view);
@@ -79,7 +80,7 @@ export async function runMiningReadCommand(parsed, context) {
                 const events = normalized.items.slice().reverse();
                 if (events.length === 0) {
                     if (parsed.outputMode === "json") {
-                        const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                        const result = buildMineLogJson(events, normalized.page, await readRotationIndices(runtimePaths));
                         writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
                             warnings: result.warnings,
                             explanations: result.explanations,
@@ -91,7 +92,7 @@ export async function runMiningReadCommand(parsed, context) {
                     return 0;
                 }
                 if (parsed.outputMode === "json") {
-                    const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                    const result = buildMineLogJson(events, normalized.page, await readRotationIndices(runtimePaths));
                     writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
                         warnings: result.warnings,
                         explanations: result.explanations,
@@ -131,6 +132,7 @@ export async function runMiningReadCommand(parsed, context) {
             dataDir,
             databasePath: dbPath,
             secretProvider: context.walletSecretProvider,
+            paths: runtimePaths,
         });
         try {
             const mining = readContext.mining ?? await context.inspectMiningControlPlane({
@@ -140,6 +142,7 @@ export async function runMiningReadCommand(parsed, context) {
                 nodeStatus: readContext.nodeStatus,
                 nodeHealth: readContext.nodeHealth,
                 indexer: readContext.indexer,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "json") {
                 const result = buildMineStatusJson(mining);

package/dist/cli/commands/mining-runtime.js

@@ -15,6 +15,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
         const provider = context.walletSecretProvider;
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "mine") {
             const abortController = new AbortController();
@@ -33,6 +34,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     stdout: context.stdout,
                     stderr: context.stderr,
                     progressOutput: parsed.progressOutput,
+                    paths: runtimePaths,
                 });
             }
             finally {
@@ -47,6 +49,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 databasePath: dbPath,
                 provider,
                 prompter: createCommandPrompter(parsed, context),
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "preview-json") {
                 writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), result.started ? "started" : "already-active", buildMineStartPreviewData(result)));
@@ -74,6 +77,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 dataDir,
                 databasePath: dbPath,
                 provider,
+                paths: runtimePaths,
             });
             const nextSteps = getMineStopNextSteps();
             if (parsed.outputMode === "preview-json") {