@cogcoin/client 1.1.9 → 1.1.11

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@1.1.9` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@1.1.10` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 

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

@@ -10,6 +10,8 @@ export declare class DefaultManagedBitcoindClient implements ManagedBitcoindClie
     constructor(client: SyncRecoveryClient, store: ClientStoreAdapter, node: ManagedBitcoindNodeHandle, rpc: BitcoinRpcClient, progress: ManagedProgressController, bootstrap: AssumeUtxoBootstrapController, startHeight: number, syncDebounceMs: number, dataDir: string, walletRootId: string, startupTimeoutMs: number | undefined, shutdownTimeoutMs: number | undefined, fetchImpl: typeof fetch | undefined);
     getTip(): Promise<import("../../types.js").ClientTip | null>;
     getState(): Promise<import("@cogcoin/indexer/types").IndexerState>;
+    readMirrorSnapshot(): Promise<import("../../types.js").ClientMirrorSnapshot>;
+    readMirrorDelta(afterHeight: number): Promise<import("../../types.js").ClientMirrorDelta>;
     applyBlock(block: BitcoinBlock): Promise<import("../../types.js").ApplyBlockResult>;
     rewindToHeight(height: number): Promise<import("../../types.js").ClientTip | null>;
     syncToTip(): Promise<SyncResult>;

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

@@ -64,6 +64,12 @@ export class DefaultManagedBitcoindClient {
     async getState() {
         return this.#client.getState();
     }
+    async readMirrorSnapshot() {
+        return this.#client.readMirrorSnapshot();
+    }
+    async readMirrorDelta(afterHeight) {
+        return this.#client.readMirrorDelta(afterHeight);
+    }
     async applyBlock(block) {
         return this.#client.applyBlock(block);
     }

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

@@ -0,0 +1,23 @@
+import type { GenesisParameters } from "@cogcoin/indexer/types";
+import { resolveManagedServicePaths } from "../service-paths.js";
+import type { ManagedIndexerDaemonStatus } from "../types.js";
+import type { IndexerDaemonRuntimeState } from "./types.js";
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorCode: string): Promise<T>;
+export declare function recordBackgroundFollowFailure(options: {
+    state: IndexerDaemonRuntimeState;
+    message: string;
+    writeStatus(): Promise<ManagedIndexerDaemonStatus>;
+}): Promise<void>;
+export declare function pauseBackgroundFollow(options: {
+    state: IndexerDaemonRuntimeState;
+}): Promise<void>;
+export declare function resumeBackgroundFollow(options: {
+    dataDir: string;
+    databasePath: string;
+    walletRootId: string;
+    paths: ReturnType<typeof resolveManagedServicePaths>;
+    state: IndexerDaemonRuntimeState;
+    genesisParameters: GenesisParameters;
+    forceResumeErrorEnv: string;
+    writeStatus(): Promise<ManagedIndexerDaemonStatus>;
+}): Promise<void>;

package/dist/bitcoind/indexer-daemon/background-follow.js

@@ -0,0 +1,132 @@
+import { openManagedBitcoindClientInternal } from "../client.js";
+import { DEFAULT_SNAPSHOT_METADATA } from "../bootstrap.js";
+import { openSqliteStore } from "../../sqlite/index.js";
+import { normalizeCogcoinProcessingStartHeight } from "../processing-start-height.js";
+import { createBootstrapProgress } from "../progress/formatting.js";
+import { resolveManagedServicePaths } from "../service-paths.js";
+import { readManagedBitcoindStatus } from "./status.js";
+export async function withTimeout(promise, timeoutMs, errorCode) {
+    let timeoutId = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error(errorCode)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+export async function recordBackgroundFollowFailure(options) {
+    const now = Date.now();
+    options.state.heartbeatAtUnixMs = now;
+    options.state.updatedAtUnixMs = now;
+    options.state.state = "failed";
+    options.state.lastError = options.message;
+    options.state.backgroundFollowError = options.message;
+    options.state.backgroundFollowActive = false;
+    options.state.bootstrapPhase = "error";
+    options.state.bootstrapProgress = {
+        ...createBootstrapProgress("error", DEFAULT_SNAPSHOT_METADATA),
+        blocks: options.state.coreBestHeight,
+        headers: options.state.coreBestHeight,
+        targetHeight: options.state.coreBestHeight,
+        message: options.message,
+        lastError: options.message,
+        updatedAt: now,
+    };
+    options.state.cogcoinSyncHeight = options.state.appliedTipHeight;
+    options.state.cogcoinSyncTargetHeight = options.state.coreBestHeight;
+    await options.writeStatus();
+}
+export async function pauseBackgroundFollow(options) {
+    const pendingResume = options.state.backgroundResumePromise;
+    options.state.backgroundResumePromise = null;
+    await pendingResume?.catch(() => undefined);
+    const client = options.state.backgroundClient;
+    const store = options.state.backgroundStore;
+    options.state.backgroundClient = null;
+    options.state.backgroundStore = null;
+    await client?.close().catch(() => undefined);
+    await store?.close().catch(() => undefined);
+    options.state.backgroundFollowError = null;
+    options.state.backgroundFollowActive = false;
+    options.state.bootstrapPhase = "paused";
+    options.state.bootstrapProgress = createBootstrapProgress("paused", DEFAULT_SNAPSHOT_METADATA);
+    options.state.cogcoinSyncHeight = options.state.appliedTipHeight;
+    options.state.cogcoinSyncTargetHeight = options.state.coreBestHeight;
+}
+export async function resumeBackgroundFollow(options) {
+    if (options.state.backgroundClient !== null) {
+        return;
+    }
+    if (options.state.backgroundResumePromise !== null) {
+        return options.state.backgroundResumePromise;
+    }
+    options.state.backgroundResumePromise = (async () => {
+        let store = null;
+        try {
+            const forcedResumeError = process.env[options.forceResumeErrorEnv]?.trim();
+            if (forcedResumeError) {
+                throw new Error(forcedResumeError);
+            }
+            const bitcoindStatus = await readManagedBitcoindStatus(options.paths);
+            store = await openSqliteStore({ filename: options.databasePath });
+            const openedStore = store;
+            const chain = bitcoindStatus?.chain ?? "main";
+            const startHeight = normalizeCogcoinProcessingStartHeight({
+                chain,
+                startHeight: bitcoindStatus?.startHeight,
+                genesisParameters: options.genesisParameters,
+            });
+            const client = await openManagedBitcoindClientInternal({
+                store: openedStore,
+                dataDir: options.dataDir,
+                chain,
+                startHeight,
+                walletRootId: options.walletRootId,
+                progressOutput: "none",
+            });
+            options.state.backgroundStore = openedStore;
+            options.state.backgroundClient = client;
+            options.state.backgroundFollowError = null;
+            options.state.backgroundFollowActive = true;
+            void client.startFollowingTip().catch(async (error) => {
+                if (options.state.backgroundClient !== client || options.state.backgroundStore !== openedStore) {
+                    return;
+                }
+                options.state.backgroundClient = null;
+                options.state.backgroundStore = null;
+                options.state.backgroundFollowActive = false;
+                await client.close().catch(() => undefined);
+                await openedStore.close().catch(() => undefined);
+                const message = error instanceof Error ? error.message : String(error);
+                await recordBackgroundFollowFailure({
+                    state: options.state,
+                    message,
+                    writeStatus: options.writeStatus,
+                }).catch(() => undefined);
+            });
+        }
+        catch (error) {
+            await store?.close().catch(() => undefined);
+            const message = error instanceof Error ? error.message : String(error);
+            await recordBackgroundFollowFailure({
+                state: options.state,
+                message,
+                writeStatus: options.writeStatus,
+            }).catch(() => undefined);
+            throw error;
+        }
+    })();
+    try {
+        await options.state.backgroundResumePromise;
+    }
+    finally {
+        options.state.backgroundResumePromise = null;
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { ManagedIndexerDaemonProbeResult } from "../managed-runtime/types.js";
+import type { IndexerDaemonClient, ManagedIndexerDaemonOwnership, ManagedIndexerDaemonServiceLifetime } from "./types.js";
+interface IndexerDaemonClientCloseOptions {
+    serviceLifetime: ManagedIndexerDaemonServiceLifetime;
+    ownership: ManagedIndexerDaemonOwnership;
+    shutdownOwnedDaemon?: (() => Promise<void>) | null;
+    requestTimeoutMs?: number;
+    resumeBackgroundFollowRequestTimeoutMs?: number;
+}
+export declare function createIndexerDaemonClient(socketPath: string, closeOptions?: IndexerDaemonClientCloseOptions | null): IndexerDaemonClient;
+export declare function probeIndexerDaemonAtSocket(socketPath: string, expectedWalletRootId: string): Promise<ManagedIndexerDaemonProbeResult<IndexerDaemonClient>>;
+export {};

package/dist/bitcoind/indexer-daemon/client.js

@@ -0,0 +1,137 @@
+import { randomUUID } from "node:crypto";
+import net from "node:net";
+import { mapIndexerDaemonTransportError, mapIndexerDaemonValidationError, validateIndexerDaemonStatus, } from "../managed-runtime/indexer-policy.js";
+const INDEXER_DAEMON_REQUEST_TIMEOUT_MS = 15_000;
+const INDEXER_DAEMON_RESUME_BACKGROUND_FOLLOW_REQUEST_TIMEOUT_MS = 35_000;
+export 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"
+                ? closeOptions?.resumeBackgroundFollowRequestTimeoutMs ?? INDEXER_DAEMON_RESUME_BACKGROUND_FOLLOW_REQUEST_TIMEOUT_MS
+                : closeOptions?.requestTimeoutMs ?? 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 closeOptions.shutdownOwnedDaemon?.();
+        },
+    };
+}
+export 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);
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { ManagedIndexerDaemonProbeResult } from "../managed-runtime/types.js";
+import type { ManagedIndexerDaemonObservedStatus } from "../types.js";
+import type { CoherentIndexerSnapshotLease, IndexerDaemonClient, IndexerDaemonStopResult, ManagedIndexerDaemonServiceLifetime } from "./types.js";
+export type { IndexerDaemonCompatibility } from "../managed-runtime/types.js";
+export declare const INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED = "indexer_daemon_background_follow_recovery_failed";
+export type IndexerDaemonProbeResult = ManagedIndexerDaemonProbeResult<IndexerDaemonClient>;
+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>;

package/dist/bitcoind/indexer-daemon/lifecycle.js

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { acquireFileLock, FileLockBusyError } from "../../wallet/fs/lock.js";
+import { buildManagedIndexerStatusFromSnapshotHandle, validateIndexerSnapshotHandle, validateIndexerSnapshotPayload, } from "../managed-runtime/indexer-policy.js";
+import { attachOrStartManagedIndexerRuntime } from "../managed-runtime/indexer-runtime.js";
+import { readJsonFileIfPresent } from "../managed-runtime/status.js";
+import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "../service-paths.js";
+import { createIndexerDaemonClient, probeIndexerDaemonAtSocket, } from "./client.js";
+import { DEFAULT_INDEXER_DAEMON_SHUTDOWN_TIMEOUT_MS, DEFAULT_INDEXER_DAEMON_STARTUP_TIMEOUT_MS, sleep, stopIndexerDaemonService as stopIndexerDaemonServiceInternal, stopIndexerDaemonServiceWithLockHeld, waitForIndexerDaemon, } from "./process.js";
+export const INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED = "indexer_daemon_background_follow_recovery_failed";
+const INDEXER_DAEMON_BACKGROUND_FOLLOW_NOT_ACTIVE = "indexer_daemon_background_follow_not_active";
+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_INDEXER_DAEMON_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, {
+            serviceLifetime,
+            ownership: "started",
+            shutdownOwnedDaemon: async () => {
+                await stopIndexerDaemonService({
+                    dataDir: options.dataDir,
+                    walletRootId,
+                    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) {
+    return stopIndexerDaemonServiceInternal({
+        ...options,
+        shutdownTimeoutMs: options.shutdownTimeoutMs ?? DEFAULT_INDEXER_DAEMON_SHUTDOWN_TIMEOUT_MS,
+    });
+}

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

@@ -0,0 +1,35 @@
+import type { ManagedIndexerDaemonStatus } from "../types.js";
+import { resolveManagedServicePaths } from "../service-paths.js";
+import type { IndexerDaemonStopResult } from "./types.js";
+export declare const DEFAULT_INDEXER_DAEMON_STARTUP_TIMEOUT_MS = 30000;
+export declare const DEFAULT_INDEXER_DAEMON_SHUTDOWN_TIMEOUT_MS = 5000;
+export declare function sleep(ms: number): Promise<void>;
+export declare function isIndexerDaemonProcessAlive(pid: number | null): Promise<boolean>;
+export declare function waitForIndexerDaemonProcessExit(pid: number, timeoutMs: number, errorCode: string): Promise<void>;
+export declare function clearIndexerDaemonRuntimeArtifacts(paths: ReturnType<typeof resolveManagedServicePaths>): Promise<void>;
+export declare function ignoreIndexerDaemonProcessNotFound(error: unknown): void;
+export declare function stopIndexerDaemonServiceWithLockHeld(options: {
+    dataDir: string;
+    walletRootId?: string;
+    shutdownTimeoutMs?: number;
+    paths?: ReturnType<typeof resolveManagedServicePaths>;
+    processId?: number | null;
+}): Promise<IndexerDaemonStopResult>;
+export declare function waitForIndexerDaemon(dataDir: string, walletRootId: string, timeoutMs: number): Promise<void>;
+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>;