@cogcoin/client 1.1.9 → 1.1.11

package/dist/bitcoind/indexer-daemon.d.ts

@@ -1,132 +1,4 @@
-import type { ManagedIndexerDaemonProbeResult } from "./managed-runtime/types.js";
-import { type BootstrapPhase, type BootstrapProgress, type ManagedIndexerDaemonObservedStatus, type ManagedIndexerDaemonStatus } from "./types.js";
-import { resolveManagedServicePaths } from "./service-paths.js";
-export type { IndexerDaemonCompatibility } from "./managed-runtime/types.js";
-export declare const INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED = "indexer_daemon_background_follow_recovery_failed";
-interface DaemonRequest {
-    id: string;
-    method: "GetStatus" | "OpenSnapshot" | "ReadSnapshot" | "CloseSnapshot" | "ResumeBackgroundFollow";
-    token?: string;
-}
-interface DaemonResponse {
-    id: string;
-    ok: boolean;
-    result?: unknown;
-    error?: string;
-}
-export interface IndexerSnapshotHandle {
-    token: string;
-    expiresAtUnixMs: number;
-    serviceApiVersion: string;
-    binaryVersion: string;
-    buildId: string | null;
-    walletRootId: string;
-    daemonInstanceId: string;
-    schemaVersion: string;
-    processId: number | null;
-    startedAtUnixMs: number;
-    state: ManagedIndexerDaemonStatus["state"];
-    heartbeatAtUnixMs: number;
-    rpcReachable: boolean;
-    coreBestHeight: number | null;
-    coreBestHash: string | null;
-    appliedTipHeight: number | null;
-    appliedTipHash: string | null;
-    snapshotSeq: string | null;
-    backlogBlocks: number | null;
-    reorgDepth: number | null;
-    lastAppliedAtUnixMs: number | null;
-    activeSnapshotCount: number;
-    lastError: string | null;
-    backgroundFollowActive: boolean;
-    bootstrapPhase: BootstrapPhase | null;
-    bootstrapProgress: BootstrapProgress | null;
-    cogcoinSyncHeight: number | null;
-    cogcoinSyncTargetHeight: number | null;
-    tipHeight: number | null;
-    tipHash: string | null;
-    openedAtUnixMs: number;
-}
-export interface IndexerSnapshotPayload {
-    token: string;
-    stateBase64: string;
-    serviceApiVersion: string;
-    schemaVersion: string;
-    walletRootId: string;
-    daemonInstanceId: string;
-    processId: number | null;
-    startedAtUnixMs: number;
-    snapshotSeq: string | null;
-    tipHeight: number | null;
-    tipHash: string | null;
-    openedAtUnixMs: number;
-    tip: {
-        height: number;
-        blockHashHex: string;
-        previousHashHex: string | null;
-        stateHashHex: string | null;
-    } | null;
-    expiresAtUnixMs: number;
-}
-export interface IndexerDaemonClient {
-    getStatus(): Promise<ManagedIndexerDaemonObservedStatus>;
-    openSnapshot(): Promise<IndexerSnapshotHandle>;
-    readSnapshot(token: string): Promise<IndexerSnapshotPayload>;
-    closeSnapshot(token: string): Promise<void>;
-    resumeBackgroundFollow(): Promise<void>;
-    close(): Promise<void>;
-}
-export type IndexerDaemonProbeResult = ManagedIndexerDaemonProbeResult<IndexerDaemonClient>;
-export interface IndexerDaemonStopResult {
-    status: "stopped" | "not-running";
-    walletRootId: string;
-}
-export interface CoherentIndexerSnapshotLease {
-    payload: IndexerSnapshotPayload;
-    status: ManagedIndexerDaemonStatus;
-}
-type ManagedIndexerDaemonServiceLifetime = "persistent" | "ephemeral";
-export declare function stopIndexerDaemonServiceWithLockHeld(options: {
-    dataDir: string;
-    walletRootId?: string;
-    shutdownTimeoutMs?: number;
-    paths?: ReturnType<typeof resolveManagedServicePaths>;
-    processId?: number | null;
-}): Promise<IndexerDaemonStopResult>;
-export declare function probeIndexerDaemon(options: {
-    dataDir: string;
-    walletRootId?: string;
-}): Promise<IndexerDaemonProbeResult>;
-export declare function readSnapshotWithRetry(daemon: IndexerDaemonClient, expectedWalletRootId: string): Promise<CoherentIndexerSnapshotLease>;
-export declare function readObservedIndexerDaemonStatus(options: {
-    dataDir: string;
-    walletRootId?: string;
-}): Promise<ManagedIndexerDaemonObservedStatus | null>;
-export declare function attachOrStartIndexerDaemon(options: {
-    dataDir: string;
-    databasePath: string;
-    walletRootId?: string;
-    startupTimeoutMs?: number;
-    shutdownTimeoutMs?: number;
-    serviceLifetime?: ManagedIndexerDaemonServiceLifetime;
-    ensureBackgroundFollow?: boolean;
-    expectedBinaryVersion?: string | null;
-}): Promise<IndexerDaemonClient>;
-export declare function stopIndexerDaemonService(options: {
-    dataDir: string;
-    walletRootId?: string;
-    shutdownTimeoutMs?: number;
-}): Promise<IndexerDaemonStopResult>;
-export declare function shutdownIndexerDaemonForTesting(options: {
-    dataDir: string;
-    walletRootId?: string;
-}): Promise<void>;
-export declare function readIndexerDaemonStatusForTesting(options: {
-    dataDir: string;
-    walletRootId?: string;
-}): Promise<ManagedIndexerDaemonStatus | null>;
-export declare function writeIndexerDaemonStatusForTesting(options: {
-    dataDir: string;
-    walletRootId?: string;
-}, status: ManagedIndexerDaemonStatus): Promise<void>;
-export type { DaemonRequest, DaemonResponse };
+export { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, stopIndexerDaemonService, } from "./indexer-daemon/lifecycle.js";
+export { readIndexerDaemonStatusForTesting, shutdownIndexerDaemonForTesting, stopIndexerDaemonServiceWithLockHeld, writeIndexerDaemonStatusForTesting, } from "./indexer-daemon/process.js";
+export type { CoherentIndexerSnapshotLease, DaemonRequest, DaemonResponse, IndexerDaemonClient, IndexerDaemonStopResult, IndexerSnapshotHandle, IndexerSnapshotPayload, ManagedIndexerDaemonOwnership, ManagedIndexerDaemonServiceLifetime, } from "./indexer-daemon/types.js";
+export type { IndexerDaemonCompatibility, IndexerDaemonProbeResult, } from "./indexer-daemon/lifecycle.js";

package/dist/bitcoind/indexer-daemon.js

@@ -1,417 +1,2 @@
-import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import { mkdir, rm } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import net from "node:net";
-import { acquireFileLock, FileLockBusyError } from "../wallet/fs/lock.js";
-import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
-import { buildManagedIndexerStatusFromSnapshotHandle, mapIndexerDaemonTransportError, mapIndexerDaemonValidationError, validateIndexerDaemonStatus, validateIndexerSnapshotHandle, validateIndexerSnapshotPayload, } from "./managed-runtime/indexer-policy.js";
-import { attachOrStartManagedIndexerRuntime } from "./managed-runtime/indexer-runtime.js";
-import { readJsonFileIfPresent } from "./managed-runtime/status.js";
-import {} from "./types.js";
-import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
-const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
-const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
-const FORCE_KILL_TIMEOUT_MS = 5_000;
-const INDEXER_DAEMON_REQUEST_TIMEOUT_MS = 15_000;
-const INDEXER_DAEMON_RESUME_BACKGROUND_FOLLOW_REQUEST_TIMEOUT_MS = 35_000;
-const INDEXER_DAEMON_BACKGROUND_FOLLOW_NOT_ACTIVE = "indexer_daemon_background_follow_not_active";
-export const INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED = "indexer_daemon_background_follow_recovery_failed";
-async function isProcessAlive(pid) {
-    if (pid === null) {
-        return false;
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
-            return false;
-        }
-        return true;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-async function waitForProcessExit(pid, timeoutMs, errorCode) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (!await isProcessAlive(pid)) {
-            return;
-        }
-        await sleep(50);
-    }
-    throw new Error(errorCode);
-}
-async function clearIndexerDaemonRuntimeArtifacts(paths) {
-    await rm(paths.indexerDaemonStatusPath, { force: true }).catch(() => undefined);
-    await rm(paths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
-}
-function ignoreProcessNotFound(error) {
-    if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
-        throw error;
-    }
-}
-export async function stopIndexerDaemonServiceWithLockHeld(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = options.paths ?? resolveManagedServicePaths(options.dataDir, walletRootId);
-    const status = await readJsonFileIfPresent(paths.indexerDaemonStatusPath);
-    const processId = options.processId ?? status?.processId ?? null;
-    if (status === null || processId === null || !await isProcessAlive(processId)) {
-        await clearIndexerDaemonRuntimeArtifacts(paths);
-        return {
-            status: "not-running",
-            walletRootId,
-        };
-    }
-    try {
-        process.kill(processId, "SIGTERM");
-    }
-    catch (error) {
-        ignoreProcessNotFound(error);
-    }
-    try {
-        await waitForProcessExit(processId, options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, "indexer_daemon_stop_timeout");
-    }
-    catch (error) {
-        if (!(error instanceof Error) || error.message !== "indexer_daemon_stop_timeout") {
-            throw error;
-        }
-        try {
-            process.kill(processId, "SIGKILL");
-        }
-        catch (killError) {
-            ignoreProcessNotFound(killError);
-        }
-        await waitForProcessExit(processId, FORCE_KILL_TIMEOUT_MS, "indexer_daemon_stop_timeout");
-    }
-    await clearIndexerDaemonRuntimeArtifacts(paths);
-    return {
-        status: "stopped",
-        walletRootId,
-    };
-}
-function createIndexerDaemonClient(socketPath, closeOptions = null) {
-    let closed = false;
-    async function sendRequest(request) {
-        return new Promise((resolve, reject) => {
-            const socket = net.createConnection(socketPath);
-            let buffer = "";
-            let settled = false;
-            const finish = (handler) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                socket.destroy();
-                handler();
-            };
-            socket.setTimeout(request.method === "ResumeBackgroundFollow"
-                ? INDEXER_DAEMON_RESUME_BACKGROUND_FOLLOW_REQUEST_TIMEOUT_MS
-                : INDEXER_DAEMON_REQUEST_TIMEOUT_MS);
-            socket.on("connect", () => {
-                socket.write(`${JSON.stringify(request)}\n`);
-            });
-            socket.on("data", (chunk) => {
-                buffer += chunk.toString("utf8");
-                let newlineIndex = buffer.indexOf("\n");
-                while (newlineIndex >= 0) {
-                    const line = buffer.slice(0, newlineIndex);
-                    buffer = buffer.slice(newlineIndex + 1);
-                    if (line.trim().length === 0) {
-                        newlineIndex = buffer.indexOf("\n");
-                        continue;
-                    }
-                    let response;
-                    try {
-                        response = JSON.parse(line);
-                    }
-                    catch (error) {
-                        finish(() => reject(error));
-                        return;
-                    }
-                    if (response.id !== request.id) {
-                        newlineIndex = buffer.indexOf("\n");
-                        continue;
-                    }
-                    if (!response.ok) {
-                        finish(() => reject(new Error(response.error ?? "indexer_daemon_request_failed")));
-                        return;
-                    }
-                    finish(() => resolve(response.result));
-                    return;
-                }
-            });
-            socket.on("timeout", () => {
-                finish(() => reject(new Error("indexer_daemon_request_timeout")));
-            });
-            socket.on("error", (error) => {
-                finish(() => reject(error));
-            });
-            socket.on("end", () => {
-                if (!settled) {
-                    finish(() => reject(new Error("indexer_daemon_connection_closed")));
-                }
-            });
-        });
-    }
-    return {
-        getStatus() {
-            return sendRequest({
-                id: randomUUID(),
-                method: "GetStatus",
-            });
-        },
-        openSnapshot() {
-            return sendRequest({
-                id: randomUUID(),
-                method: "OpenSnapshot",
-            });
-        },
-        readSnapshot(token) {
-            return sendRequest({
-                id: randomUUID(),
-                method: "ReadSnapshot",
-                token,
-            });
-        },
-        async closeSnapshot(token) {
-            await sendRequest({
-                id: randomUUID(),
-                method: "CloseSnapshot",
-                token,
-            });
-        },
-        async resumeBackgroundFollow() {
-            await sendRequest({
-                id: randomUUID(),
-                method: "ResumeBackgroundFollow",
-            });
-        },
-        async close() {
-            if (closed) {
-                return;
-            }
-            closed = true;
-            if (closeOptions === null || closeOptions.serviceLifetime !== "ephemeral" || closeOptions.ownership === "attached") {
-                return;
-            }
-            await stopIndexerDaemonService({
-                dataDir: closeOptions.dataDir,
-                walletRootId: closeOptions.walletRootId,
-                shutdownTimeoutMs: closeOptions.shutdownTimeoutMs,
-            });
-        },
-    };
-}
-async function probeIndexerDaemonAtSocket(socketPath, expectedWalletRootId) {
-    const client = createIndexerDaemonClient(socketPath);
-    try {
-        const status = await client.getStatus();
-        try {
-            validateIndexerDaemonStatus(status, expectedWalletRootId);
-            return {
-                compatibility: "compatible",
-                status,
-                client,
-                error: null,
-            };
-        }
-        catch (error) {
-            await client.close().catch(() => undefined);
-            return mapIndexerDaemonValidationError(error, status);
-        }
-    }
-    catch (error) {
-        await client.close().catch(() => undefined);
-        return mapIndexerDaemonTransportError(error);
-    }
-}
-async function waitForIndexerDaemon(dataDir, walletRootId, timeoutMs) {
-    const paths = resolveManagedServicePaths(dataDir, walletRootId);
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const probe = await probeIndexerDaemonAtSocket(paths.indexerDaemonSocketPath, walletRootId);
-        if (probe.compatibility === "compatible" && probe.client !== null) {
-            await probe.client.close().catch(() => undefined);
-            return;
-        }
-        if (probe.compatibility !== "unreachable") {
-            throw new Error(probe.error ?? "indexer_daemon_protocol_error");
-        }
-        await sleep(250);
-    }
-    throw new Error("indexer_daemon_start_timeout");
-}
-export async function probeIndexerDaemon(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    return probeIndexerDaemonAtSocket(paths.indexerDaemonSocketPath, walletRootId);
-}
-export async function readSnapshotWithRetry(daemon, expectedWalletRootId) {
-    let lastError = null;
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const handle = await daemon.openSnapshot();
-        try {
-            validateIndexerSnapshotHandle(handle, expectedWalletRootId);
-            const payload = await daemon.readSnapshot(handle.token);
-            validateIndexerSnapshotPayload(payload, handle, expectedWalletRootId);
-            return {
-                payload,
-                status: buildManagedIndexerStatusFromSnapshotHandle(handle),
-            };
-        }
-        catch (error) {
-            lastError = error;
-            if (!(error instanceof Error)
-                || (error.message !== "indexer_daemon_snapshot_invalid" && error.message !== "indexer_daemon_snapshot_rotated")
-                || attempt > 0) {
-                throw error;
-            }
-        }
-        finally {
-            await daemon.closeSnapshot(handle.token).catch(() => undefined);
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error("indexer_daemon_snapshot_invalid");
-}
-export async function readObservedIndexerDaemonStatus(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    return readJsonFileIfPresent(paths.indexerDaemonStatusPath);
-}
-export async function attachOrStartIndexerDaemon(options) {
-    const requestBackgroundFollow = async (client, observedStatus = null) => {
-        if (options.ensureBackgroundFollow !== true) {
-            return client;
-        }
-        if (observedStatus?.backgroundFollowActive === true) {
-            return client;
-        }
-        await client.resumeBackgroundFollow();
-        const status = await client.getStatus();
-        if (status.backgroundFollowActive !== true) {
-            throw new Error(INDEXER_DAEMON_BACKGROUND_FOLLOW_NOT_ACTIVE);
-        }
-        return client;
-    };
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-    const serviceLifetime = options.serviceLifetime ?? "persistent";
-    const expectedBinaryVersion = options.expectedBinaryVersion ?? null;
-    const startDaemon = async () => {
-        await mkdir(paths.indexerServiceRoot, { recursive: true });
-        const daemonEntryPath = fileURLToPath(new URL("./indexer-daemon-main.js", import.meta.url));
-        const spawnOptions = serviceLifetime === "ephemeral"
-            ? {
-                stdio: "ignore",
-            }
-            : {
-                detached: true,
-                stdio: "ignore",
-            };
-        const child = spawn(process.execPath, [
-            daemonEntryPath,
-            `--data-dir=${options.dataDir}`,
-            `--database-path=${options.databasePath}`,
-            `--wallet-root-id=${walletRootId}`,
-        ], {
-            ...spawnOptions,
-        });
-        if (serviceLifetime !== "ephemeral") {
-            child.unref();
-        }
-        try {
-            await waitForIndexerDaemon(options.dataDir, walletRootId, startupTimeoutMs);
-        }
-        catch (error) {
-            if (child.pid !== undefined) {
-                try {
-                    process.kill(child.pid, "SIGTERM");
-                }
-                catch {
-                    // ignore shutdown failures while unwinding startup errors
-                }
-            }
-            throw error;
-        }
-        return createIndexerDaemonClient(paths.indexerDaemonSocketPath, {
-            dataDir: options.dataDir,
-            walletRootId,
-            serviceLifetime,
-            ownership: "started",
-            shutdownTimeoutMs: options.shutdownTimeoutMs,
-        });
-    };
-    return attachOrStartManagedIndexerRuntime({
-        ...options,
-        walletRootId,
-        startupTimeoutMs,
-        expectedBinaryVersion,
-    }, {
-        getPaths: (runtimeOptions) => resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
-        probeDaemon: async (runtimeOptions, runtimePaths) => probeIndexerDaemonAtSocket(runtimePaths.indexerDaemonSocketPath, runtimeOptions.walletRootId),
-        requestBackgroundFollow,
-        closeClient: async (client) => {
-            await client.close();
-        },
-        acquireStartLock: async (runtimeOptions, runtimePaths) => acquireFileLock(runtimePaths.indexerDaemonLockPath, {
-            purpose: "indexer-daemon-start",
-            walletRootId: runtimeOptions.walletRootId,
-            dataDir: runtimeOptions.dataDir,
-            databasePath: runtimeOptions.databasePath,
-        }),
-        startDaemon: async () => startDaemon(),
-        stopWithLockHeld: async (runtimeOptions, runtimePaths, processId) => stopIndexerDaemonServiceWithLockHeld({
-            dataDir: runtimeOptions.dataDir,
-            walletRootId: runtimeOptions.walletRootId,
-            shutdownTimeoutMs: runtimeOptions.shutdownTimeoutMs,
-            paths: resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
-            processId,
-        }),
-        isLockBusyError: (error) => error instanceof FileLockBusyError,
-        sleep,
-    });
-}
-export async function stopIndexerDaemonService(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    const lock = await acquireFileLock(paths.indexerDaemonLockPath, {
-        purpose: "indexer-daemon-stop",
-        walletRootId,
-        dataDir: options.dataDir,
-    });
-    try {
-        return await stopIndexerDaemonServiceWithLockHeld({
-            ...options,
-            walletRootId,
-            paths,
-        });
-    }
-    finally {
-        await lock.release();
-    }
-}
-export async function shutdownIndexerDaemonForTesting(options) {
-    await stopIndexerDaemonService(options).catch(async () => {
-        const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-        const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-        await rm(paths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
-    });
-}
-export async function readIndexerDaemonStatusForTesting(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    return readJsonFileIfPresent(paths.indexerDaemonStatusPath);
-}
-export async function writeIndexerDaemonStatusForTesting(options, status) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
-    await mkdir(paths.indexerServiceRoot, { recursive: true });
-    await writeRuntimeStatusFile(paths.indexerDaemonStatusPath, status);
-}
+export { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, stopIndexerDaemonService, } from "./indexer-daemon/lifecycle.js";
+export { readIndexerDaemonStatusForTesting, shutdownIndexerDaemonForTesting, stopIndexerDaemonServiceWithLockHeld, writeIndexerDaemonStatusForTesting, } from "./indexer-daemon/process.js";

package/dist/bitcoind/managed-bitcoind-service-config.d.ts

@@ -0,0 +1,30 @@
+import { writeJsonFileAtomic } from "../wallet/fs/atomic.js";
+import type { BitcoindRpcConfig, BitcoindZmqConfig, ManagedBitcoindRuntimeConfig, ManagedBitcoindServiceStatus } from "./types.js";
+import type { ManagedBitcoindServiceOptions } from "./managed-bitcoind-service-types.js";
+export declare const LOCAL_HOST = "127.0.0.1";
+export declare const SUPPORTED_BITCOIND_VERSION = "30.2.0";
+export interface ManagedBitcoindRuntimeConfigFile {
+    chain: ManagedBitcoindRuntimeConfig["chain"];
+    rpc: ManagedBitcoindRuntimeConfig["rpc"];
+    zmqPort: ManagedBitcoindRuntimeConfig["zmqPort"];
+    p2pPort: ManagedBitcoindRuntimeConfig["p2pPort"];
+    getblockArchiveEndHeight: ManagedBitcoindRuntimeConfig["getblockArchiveEndHeight"];
+    getblockArchiveSha256: ManagedBitcoindRuntimeConfig["getblockArchiveSha256"];
+}
+type ManagedBitcoindRuntimeConfigFileDeps = {
+    readJsonFileIfPresent: (filePath: string) => Promise<ManagedBitcoindRuntimeConfigFile | null>;
+    writeJsonFileAtomic: typeof writeJsonFileAtomic;
+};
+export declare function resolveManagedBitcoindDbcacheMiB(totalRamBytes: number): number;
+export declare function detectManagedBitcoindDbcacheMiB(): number;
+export declare function verifyManagedBitcoindVersion(bitcoindPath: string): Promise<void>;
+export declare function getManagedBitcoindCookieFile(dataDir: string, chain: "main" | "regtest"): string;
+export declare function resolveManagedBitcoindRuntimeConfig(statusPath: string, configPath: string, options: ManagedBitcoindServiceOptions): Promise<ManagedBitcoindRuntimeConfig>;
+export declare function createManagedBitcoindRuntimeConfigFilePayload(runtimeConfig: ManagedBitcoindRuntimeConfig): ManagedBitcoindRuntimeConfigFile;
+export declare function createManagedBitcoindRuntimeConfigFilePayloadFromStatus(status: Pick<ManagedBitcoindServiceStatus, "chain" | "rpc" | "zmq" | "p2pPort" | "getblockArchiveEndHeight" | "getblockArchiveSha256">): ManagedBitcoindRuntimeConfigFile;
+export declare function writeManagedBitcoindRuntimeConfigFile(filePath: string, runtimeConfig: ManagedBitcoindRuntimeConfig, dependencies?: ManagedBitcoindRuntimeConfigFileDeps): Promise<void>;
+export declare function writeManagedBitcoindRuntimeConfigFileFromStatus(filePath: string, status: Pick<ManagedBitcoindServiceStatus, "chain" | "rpc" | "zmq" | "p2pPort" | "getblockArchiveEndHeight" | "getblockArchiveSha256">, dependencies?: ManagedBitcoindRuntimeConfigFileDeps): Promise<void>;
+export declare function writeBitcoinConfForTesting(filePath: string, options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): Promise<void>;
+export declare function buildManagedServiceArgsForTesting(options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): string[];
+export declare function waitForManagedBitcoindCookie(cookieFile: string, timeoutMs: number, sleepImpl: (ms: number) => Promise<void>): Promise<void>;
+export type { BitcoindRpcConfig, BitcoindZmqConfig, };