@cogcoin/client 0.5.4 → 0.5.6

package/dist/bitcoind/retryable-rpc.js

@@ -0,0 +1,30 @@
+export const MANAGED_RPC_RETRY_BASE_MS = 1_000;
+export const MANAGED_RPC_RETRY_MAX_MS = 15_000;
+export const MANAGED_RPC_RETRY_MESSAGE = "Managed Bitcoin RPC temporarily unavailable; retrying until canceled.";
+export function createManagedRpcRetryState() {
+    return {
+        nextDelayMs: MANAGED_RPC_RETRY_BASE_MS,
+    };
+}
+export function resetManagedRpcRetryState(state) {
+    state.nextDelayMs = MANAGED_RPC_RETRY_BASE_MS;
+}
+export function consumeManagedRpcRetryDelayMs(state) {
+    const delayMs = state.nextDelayMs;
+    state.nextDelayMs = Math.min(state.nextDelayMs * 2, MANAGED_RPC_RETRY_MAX_MS);
+    return delayMs;
+}
+export function isRetryableManagedRpcError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "bitcoind_rpc_timeout") {
+        return true;
+    }
+    if (message.startsWith("The managed Bitcoin RPC request to ")) {
+        return message.includes(" failed");
+    }
+    return message.startsWith("The managed Bitcoin RPC cookie file is unavailable at ")
+        || message.startsWith("The managed Bitcoin RPC cookie file could not be read at ");
+}
+export function describeManagedRpcRetryError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/bitcoind/service.d.ts

@@ -1,4 +1,6 @@
-import type { InternalManagedBitcoindOptions, ManagedBitcoindObservedStatus, ManagedBitcoindNodeHandle, ManagedCoreWalletReplicaStatus } from "./types.js";
+import { resolveManagedServicePaths } from "./service-paths.js";
+import type { InternalManagedBitcoindOptions, ManagedBitcoindObservedStatus, ManagedBitcoindRuntimeConfig, ManagedBitcoindNodeHandle, ManagedCoreWalletReplicaStatus } from "./types.js";
+export declare function resolveManagedBitcoindDbcacheMiB(totalRamBytes: number): number;
 interface ManagedWalletReplicaRpc {
     listWallets(): Promise<string[]>;
     loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
@@ -29,9 +31,22 @@ export interface ManagedBitcoindServiceStopResult {
     status: "stopped" | "not-running";
     walletRootId: string;
 }
+export declare function writeBitcoinConfForTesting(filePath: string, options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): Promise<void>;
+export declare function buildManagedServiceArgsForTesting(options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): string[];
 export declare function createManagedWalletReplica(rpc: ManagedWalletReplicaRpc, walletRootId: string, options?: {
     managedWalletPassphrase?: string;
 }): Promise<ManagedCoreWalletReplicaStatus>;
+export declare function stopManagedBitcoindServiceWithLockHeld(options: {
+    dataDir: string;
+    walletRootId?: string;
+    shutdownTimeoutMs?: number;
+    paths?: ReturnType<typeof resolveManagedServicePaths>;
+}): Promise<ManagedBitcoindServiceStopResult>;
+export declare function withClaimedUninitializedManagedRuntime<T>(options: {
+    dataDir: string;
+    walletRootId?: string;
+    shutdownTimeoutMs?: number;
+}, callback: () => Promise<T>): Promise<T>;
 export declare function probeManagedBitcoindService(options: ManagedBitcoindServiceOptions): Promise<ManagedBitcoindServiceProbeResult>;
 export declare function attachOrStartManagedBitcoindService(options: ManagedBitcoindServiceOptions): Promise<ManagedBitcoindNodeHandle>;
 export declare function stopManagedBitcoindService(options: {

package/dist/bitcoind/service.js

@@ -2,12 +2,14 @@ import { randomBytes } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { access, constants, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { totalmem } from "node:os";
 import { promisify } from "node:util";
 import net from "node:net";
 import { getBitcoindPath } from "@cogcoin/bitcoin";
 import { acquireFileLock, FileLockBusyError } from "../wallet/fs/lock.js";
 import { writeFileAtomic } from "../wallet/fs/atomic.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
+import { stopIndexerDaemonServiceWithLockHeld } from "./indexer-daemon.js";
 import { createRpcClient, validateNodeConfigForTesting } from "./node.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
 import { MANAGED_BITCOIND_SERVICE_API_VERSION as MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE } from "./types.js";
@@ -16,6 +18,32 @@ const LOCAL_HOST = "127.0.0.1";
 const SUPPORTED_BITCOIND_VERSION = "30.2.0";
 const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 15_000;
+const DEFAULT_DBCACHE_MIB = 450;
+const claimedUninitializedRuntimeKeys = new Set();
+const GIB = 1024 ** 3;
+export function resolveManagedBitcoindDbcacheMiB(totalRamBytes) {
+    if (!Number.isFinite(totalRamBytes) || totalRamBytes <= 0) {
+        return DEFAULT_DBCACHE_MIB;
+    }
+    if (totalRamBytes < 8 * GIB) {
+        return 450;
+    }
+    if (totalRamBytes < 16 * GIB) {
+        return 768;
+    }
+    if (totalRamBytes < 32 * GIB) {
+        return 1024;
+    }
+    return 2048;
+}
+function detectManagedBitcoindDbcacheMiB() {
+    try {
+        return resolveManagedBitcoindDbcacheMiB(totalmem());
+    }
+    catch {
+        return DEFAULT_DBCACHE_MIB;
+    }
+}
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -31,6 +59,20 @@ async function waitForProcessExit(pid, timeoutMs, errorCode) {
     }
     throw new Error(errorCode);
 }
+async function acquireFileLockWithRetry(lockPath, metadata, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            return await acquireFileLock(lockPath, metadata);
+        }
+        catch (error) {
+            if (!(error instanceof FileLockBusyError) || Date.now() >= deadline) {
+                throw error;
+            }
+            await sleep(250);
+        }
+    }
+}
 function getWalletReplicaName(walletRootId) {
     return `cogcoin-${walletRootId}`.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 63);
 }
@@ -323,6 +365,7 @@ async function resolveRuntimeConfig(statusPath, configPath, options) {
         },
         zmqPort,
         p2pPort,
+        dbcacheMiB: detectManagedBitcoindDbcacheMiB(),
     };
 }
 async function writeBitcoinConf(filePath, options, runtimeConfig) {
@@ -334,6 +377,7 @@ async function writeBitcoinConf(filePath, options, runtimeConfig) {
         "prune=0",
         "dnsseed=1",
         "listen=0",
+        `dbcache=${runtimeConfig.dbcacheMiB}`,
         `rpcbind=${LOCAL_HOST}`,
         `rpcallowip=${LOCAL_HOST}`,
         `rpcport=${runtimeConfig.rpc.port}`,
@@ -358,12 +402,19 @@ function buildManagedServiceArgs(options, runtimeConfig) {
         "-prune=0",
         "-dnsseed=1",
         "-listen=0",
+        `-dbcache=${runtimeConfig.dbcacheMiB}`,
     ];
     if (options.chain === "regtest") {
         args.push("-chain=regtest");
     }
     return args;
 }
+export async function writeBitcoinConfForTesting(filePath, options, runtimeConfig) {
+    await writeBitcoinConf(filePath, options, runtimeConfig);
+}
+export function buildManagedServiceArgsForTesting(options, runtimeConfig) {
+    return buildManagedServiceArgs(options, runtimeConfig);
+}
 function isMissingWalletError(message) {
     return message.includes("bitcoind_rpc_loadwallet_-18_")
         || message.includes("Path does not exist")
@@ -504,6 +555,86 @@ async function clearManagedBitcoindRuntimeArtifacts(paths) {
     await rm(paths.bitcoindReadyPath, { force: true }).catch(() => undefined);
     await rm(paths.bitcoindWalletStatusPath, { force: true }).catch(() => undefined);
 }
+export async function stopManagedBitcoindServiceWithLockHeld(options) {
+    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
+    const paths = options.paths ?? resolveManagedServicePaths(options.dataDir, walletRootId);
+    const status = await readJsonFile(paths.bitcoindStatusPath);
+    const processId = status?.processId ?? null;
+    if (status === null || processId === null || !await isProcessAlive(processId)) {
+        await clearManagedBitcoindRuntimeArtifacts(paths);
+        return {
+            status: "not-running",
+            walletRootId,
+        };
+    }
+    const rpc = createRpcClient(status.rpc);
+    try {
+        await rpc.stop();
+    }
+    catch {
+        try {
+            process.kill(processId, "SIGTERM");
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+                throw error;
+            }
+        }
+    }
+    await waitForProcessExit(processId, options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, "managed_bitcoind_service_stop_timeout");
+    await clearManagedBitcoindRuntimeArtifacts(paths);
+    return {
+        status: "stopped",
+        walletRootId,
+    };
+}
+export async function withClaimedUninitializedManagedRuntime(options, callback) {
+    const targetWalletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
+    if (targetWalletRootId === UNINITIALIZED_WALLET_ROOT_ID) {
+        return callback();
+    }
+    const claimKey = `${options.dataDir}\n${targetWalletRootId}`;
+    if (claimedUninitializedRuntimeKeys.has(claimKey)) {
+        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",
+        walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
+        dataDir: options.dataDir,
+    }, lockTimeoutMs);
+    try {
+        const indexerLock = await acquireFileLockWithRetry(uninitializedPaths.indexerDaemonLockPath, {
+            purpose: "managed-indexer-claim-uninitialized",
+            walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
+            dataDir: options.dataDir,
+        }, lockTimeoutMs);
+        try {
+            await stopIndexerDaemonServiceWithLockHeld({
+                dataDir: options.dataDir,
+                walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
+                shutdownTimeoutMs: options.shutdownTimeoutMs,
+                paths: uninitializedPaths,
+            });
+            await stopManagedBitcoindServiceWithLockHeld({
+                dataDir: options.dataDir,
+                walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
+                shutdownTimeoutMs: options.shutdownTimeoutMs,
+                paths: uninitializedPaths,
+            });
+            return await callback();
+        }
+        finally {
+            await indexerLock.release();
+        }
+    }
+    finally {
+        claimedUninitializedRuntimeKeys.delete(claimKey);
+        await bitcoindLock.release();
+    }
+}
 async function refreshManagedBitcoindStatus(status, paths, options) {
     const nowUnixMs = Date.now();
     const rpc = createRpcClient(status.rpc);
@@ -617,103 +748,109 @@ export async function attachOrStartManagedBitcoindService(options) {
         dataDir: options.dataDir,
         walletRootId: options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
     };
-    const existingProbe = await probeManagedBitcoindService(resolvedOptions);
-    if (existingProbe.compatibility === "compatible") {
-        const existing = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-        if (existing !== null) {
-            return existing;
-        }
-    }
-    if (existingProbe.compatibility !== "unreachable") {
-        throw new Error(existingProbe.error ?? "managed_bitcoind_protocol_error");
-    }
-    const paths = resolveManagedServicePaths(resolvedOptions.dataDir ?? "", resolvedOptions.walletRootId);
     const startupTimeoutMs = resolvedOptions.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-    try {
-        const lock = await acquireFileLock(paths.bitcoindLockPath, {
-            purpose: "managed-bitcoind-start",
-            walletRootId: resolvedOptions.walletRootId,
-            dataDir: resolvedOptions.dataDir,
-        });
-        try {
-            const liveProbe = await probeManagedBitcoindService(resolvedOptions);
-            if (liveProbe.compatibility === "compatible") {
-                const reattached = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-                if (reattached !== null) {
-                    return reattached;
-                }
-            }
-            if (liveProbe.compatibility !== "unreachable") {
-                throw new Error(liveProbe.error ?? "managed_bitcoind_protocol_error");
+    return withClaimedUninitializedManagedRuntime({
+        dataDir: resolvedOptions.dataDir ?? "",
+        walletRootId: resolvedOptions.walletRootId,
+        shutdownTimeoutMs: resolvedOptions.shutdownTimeoutMs,
+    }, async () => {
+        const existingProbe = await probeManagedBitcoindService(resolvedOptions);
+        if (existingProbe.compatibility === "compatible") {
+            const existing = await tryAttachExistingManagedBitcoindService(resolvedOptions);
+            if (existing !== null) {
+                return existing;
             }
-            const bitcoindPath = await getBitcoindPath();
-            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 child = spawn(bitcoindPath, buildManagedServiceArgs(resolvedOptions, runtimeConfig), {
-                detached: true,
-                stdio: "ignore",
+        }
+        if (existingProbe.compatibility !== "unreachable") {
+            throw new Error(existingProbe.error ?? "managed_bitcoind_protocol_error");
+        }
+        const paths = resolveManagedServicePaths(resolvedOptions.dataDir ?? "", resolvedOptions.walletRootId);
+        try {
+            const lock = await acquireFileLock(paths.bitcoindLockPath, {
+                purpose: "managed-bitcoind-start",
+                walletRootId: resolvedOptions.walletRootId,
+                dataDir: resolvedOptions.dataDir,
             });
-            child.unref();
-            const rpc = createRpcClient(rpcConfig);
             try {
-                await waitForRpcReady(rpc, rpcConfig.cookieFile, resolvedOptions.chain, startupTimeoutMs);
-                await validateNodeConfigForTesting(rpc, resolvedOptions.chain, zmqConfig.endpoint);
-            }
-            catch (error) {
-                if (child.pid !== undefined) {
-                    try {
-                        process.kill(child.pid, "SIGTERM");
+                const liveProbe = await probeManagedBitcoindService(resolvedOptions);
+                if (liveProbe.compatibility === "compatible") {
+                    const reattached = await tryAttachExistingManagedBitcoindService(resolvedOptions);
+                    if (reattached !== null) {
+                        return reattached;
                     }
-                    catch {
-                        // ignore kill failures during startup cleanup
+                }
+                if (liveProbe.compatibility !== "unreachable") {
+                    throw new Error(liveProbe.error ?? "managed_bitcoind_protocol_error");
+                }
+                const bitcoindPath = await getBitcoindPath();
+                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 child = spawn(bitcoindPath, buildManagedServiceArgs(resolvedOptions, runtimeConfig), {
+                    detached: true,
+                    stdio: "ignore",
+                });
+                child.unref();
+                const rpc = createRpcClient(rpcConfig);
+                try {
+                    await waitForRpcReady(rpc, rpcConfig.cookieFile, resolvedOptions.chain, startupTimeoutMs);
+                    await validateNodeConfigForTesting(rpc, resolvedOptions.chain, zmqConfig.endpoint);
+                }
+                catch (error) {
+                    if (child.pid !== undefined) {
+                        try {
+                            process.kill(child.pid, "SIGTERM");
+                        }
+                        catch {
+                            // ignore kill failures during startup cleanup
+                        }
                     }
+                    throw error;
                 }
-                throw error;
+                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);
+            }
+            finally {
+                await lock.release();
             }
-            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);
-        }
-        finally {
-            await lock.release();
         }
-    }
-    catch (error) {
-        if (error instanceof FileLockBusyError) {
-            return waitForManagedBitcoindService(resolvedOptions, startupTimeoutMs);
+        catch (error) {
+            if (error instanceof FileLockBusyError) {
+                return waitForManagedBitcoindService(resolvedOptions, startupTimeoutMs);
+            }
+            throw error;
         }
-        throw error;
-    }
+    });
 }
 export async function stopManagedBitcoindService(options) {
     const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
@@ -724,35 +861,11 @@ export async function stopManagedBitcoindService(options) {
         dataDir: options.dataDir,
     });
     try {
-        const status = await readJsonFile(paths.bitcoindStatusPath);
-        const processId = status?.processId ?? null;
-        if (status === null || processId === null || !await isProcessAlive(processId)) {
-            await clearManagedBitcoindRuntimeArtifacts(paths);
-            return {
-                status: "not-running",
-                walletRootId,
-            };
-        }
-        const rpc = createRpcClient(status.rpc);
-        try {
-            await rpc.stop();
-        }
-        catch {
-            try {
-                process.kill(processId, "SIGTERM");
-            }
-            catch (error) {
-                if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
-                    throw error;
-                }
-            }
-        }
-        await waitForProcessExit(processId, options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, "managed_bitcoind_service_stop_timeout");
-        await clearManagedBitcoindRuntimeArtifacts(paths);
-        return {
-            status: "stopped",
+        return stopManagedBitcoindServiceWithLockHeld({
+            ...options,
             walletRootId,
-        };
+            paths,
+        });
     }
     finally {
         await lock.release();

package/dist/bitcoind/testing.d.ts

@@ -2,7 +2,7 @@ export { openManagedBitcoindClientInternal } from "./client.js";
 export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopIndexerDaemonService, shutdownIndexerDaemonForTesting, } from "./indexer-daemon.js";
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
-export { attachOrStartManagedBitcoindService, readManagedBitcoindServiceStatusForTesting, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, } from "./service.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 { 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";

package/dist/bitcoind/testing.js

@@ -2,7 +2,7 @@ export { openManagedBitcoindClientInternal } from "./client.js";
 export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopIndexerDaemonService, shutdownIndexerDaemonForTesting, } from "./indexer-daemon.js";
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
-export { attachOrStartManagedBitcoindService, readManagedBitcoindServiceStatusForTesting, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, } from "./service.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 { 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";

package/dist/bitcoind/types.d.ts

@@ -8,6 +8,15 @@ export interface SnapshotMetadata {
     sha256: string;
     sizeBytes: number;
 }
+export interface SnapshotChunkManifest {
+    formatVersion: number;
+    chunkSizeBytes: number;
+    snapshotFilename: string;
+    snapshotHeight: number;
+    snapshotSizeBytes: number;
+    snapshotSha256: string;
+    chunkSha256s: string[];
+}
 export interface WritingQuote {
     quote: string;
     author: string;
@@ -53,6 +62,7 @@ export interface ManagedBitcoindRuntimeConfig {
     rpc: BitcoindRpcConfig;
     zmqPort: number;
     p2pPort: number;
+    dbcacheMiB: number;
 }
 export declare const MANAGED_BITCOIND_SERVICE_API_VERSION = "cogcoin/bitcoind-service/v1";
 export type ManagedBitcoindServiceState = "starting" | "ready" | "stopping" | "failed";

package/dist/cli/commands/follow.js

@@ -1,10 +1,18 @@
 import { dirname } from "node:path";
+import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher } from "../signals.js";
 export async function runFollowCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
+        paths: context.resolveWalletRuntimePaths(),
+        provider: context.walletSecretProvider,
+        loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
+        loadUnlockSession: context.loadUnlockSession,
+        loadWalletExplicitLock: context.loadWalletExplicitLock,
+    });
     await context.ensureDirectory(dirname(dbPath));
     const store = await context.openSqliteStore({ filename: dbPath });
     let storeOwned = true;
@@ -13,6 +21,7 @@ export async function runFollowCommand(parsed, context) {
             store,
             databasePath: dbPath,
             dataDir,
+            walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
         });
         storeOwned = false;