@cogcoin/client 1.1.5 → 1.1.7

package/dist/wallet/read/context.js

@@ -1,13 +1,10 @@
 import { access, constants } from "node:fs/promises";
-import { deserializeIndexerState, loadBundledGenesisParameters } from "@cogcoin/indexer";
 import { readPackageVersionFromDisk } from "../../package-version.js";
-import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { UNINITIALIZED_WALLET_ROOT_ID } from "../../bitcoind/service-paths.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
-import { resolveCogcoinProcessingStartHeight } from "../../bitcoind/processing-start-height.js";
+import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import {} from "../../bitcoind/types.js";
-import { verifyManagedCoreWalletReplica, } from "../lifecycle.js";
 import { normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
 import { persistNormalizedWalletDescriptorStateIfNeeded } from "../descriptor-normalization.js";
 import { inspectMiningControlPlane } from "../mining/index.js";
@@ -17,12 +14,9 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, } from "../state/storage.js";
 import { createDefaultWalletSecretProvider, createWalletSecretReference, inspectClientPasswordSetupReadiness, } from "../state/provider.js";
 import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.js";
+import { openManagedWalletReadServiceBundle } from "./managed-services.js";
 import { createWalletReadModel } from "./project.js";
 const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
-const STALE_HEARTBEAT_THRESHOLD_MS = 15_000;
-const TOLERATED_NODE_HEADER_LEAD_BLOCKS = 2;
-const TOLERATED_NODE_HEADER_LEAD_MESSAGE = "Bitcoin headers can briefly lead validated blocks; a short 1-2 block lead is normal and is being tolerated.";
-const NODE_CATCHING_UP_MESSAGE = "Bitcoin Core is still catching up to headers.";
 function btcAmountToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
@@ -222,279 +216,6 @@ async function inspectWalletLocalState(options = {}) {
         };
     }
 }
-function mapIndexerStartupError(message) {
-    switch (message) {
-        case "indexer_daemon_start_timeout":
-            return {
-                health: "starting",
-                message: "Indexer daemon is still starting.",
-            };
-        case "indexer_daemon_service_version_mismatch":
-            return {
-                health: "service-version-mismatch",
-                message: "The live indexer daemon is running an incompatible service API version.",
-            };
-        case "indexer_daemon_schema_mismatch":
-            return {
-                health: "schema-mismatch",
-                message: "The live indexer daemon is using an incompatible sqlite schema.",
-            };
-        case "indexer_daemon_wallet_root_mismatch":
-            return {
-                health: "wallet-root-mismatch",
-                message: "The live indexer daemon belongs to a different wallet root.",
-            };
-        case "indexer_daemon_protocol_error":
-            return {
-                health: "unavailable",
-                message: "The live indexer daemon socket responded with an invalid or incomplete protocol exchange.",
-            };
-        case INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED:
-            return {
-                health: "failed",
-                message: "The managed indexer daemon could not recover automatic background follow.",
-            };
-        default:
-            return {
-                health: "unavailable",
-                message,
-            };
-    }
-}
-function mapBitcoindStartupError(message) {
-    switch (message) {
-        case "managed_bitcoind_service_start_timeout":
-            return {
-                health: "starting",
-                status: null,
-                message: "Managed bitcoind service is still starting.",
-            };
-        case "managed_bitcoind_service_version_mismatch":
-            return {
-                health: "service-version-mismatch",
-                status: null,
-                message: "The live managed bitcoind service is running an incompatible service version.",
-            };
-        case "managed_bitcoind_wallet_root_mismatch":
-            return {
-                health: "wallet-root-mismatch",
-                status: null,
-                message: "The live managed bitcoind service belongs to a different wallet root.",
-            };
-        case "managed_bitcoind_runtime_mismatch":
-            return {
-                health: "runtime-mismatch",
-                status: null,
-                message: "The live managed bitcoind service runtime does not match this wallet's expected data directory or chain.",
-            };
-        case "managed_bitcoind_protocol_error":
-            return {
-                health: "unavailable",
-                status: null,
-                message: "The managed bitcoind runtime artifacts are invalid or incomplete.",
-            };
-        default:
-            return {
-                health: "unavailable",
-                status: null,
-                message,
-            };
-    }
-}
-function deriveBitcoindHealth(options) {
-    if (options.startupError !== null) {
-        const mapped = mapBitcoindStartupError(options.startupError);
-        return {
-            ...mapped,
-            status: options.status,
-        };
-    }
-    if (options.status === null) {
-        return {
-            health: "unavailable",
-            status: null,
-            message: "Managed bitcoind service is unavailable.",
-        };
-    }
-    if (options.status.state === "starting") {
-        return {
-            health: "starting",
-            status: options.status,
-            message: options.status.lastError ?? "Managed bitcoind service is still starting.",
-        };
-    }
-    if (options.status.state === "failed") {
-        return {
-            health: "failed",
-            status: options.status,
-            message: options.status.lastError ?? "Managed bitcoind service refresh failed.",
-        };
-    }
-    const proofStatus = options.nodeStatus?.walletReplica?.proofStatus;
-    if (proofStatus === "missing") {
-        return {
-            health: "replica-missing",
-            status: options.status,
-            message: options.nodeStatus?.walletReplicaMessage ?? "Managed Core wallet replica is missing.",
-        };
-    }
-    if (proofStatus === "mismatch") {
-        return {
-            health: "replica-mismatch",
-            status: options.status,
-            message: options.nodeStatus?.walletReplicaMessage ?? "Managed Core wallet replica does not match trusted wallet state.",
-        };
-    }
-    return {
-        health: "ready",
-        status: options.status,
-        message: options.nodeStatus?.walletReplicaMessage ?? options.status.lastError,
-    };
-}
-function deriveNodeHealth(status, bitcoindHealth) {
-    if (bitcoindHealth !== "ready" || status === null || !status.ready) {
-        return {
-            health: "catching-up",
-            message: NODE_CATCHING_UP_MESSAGE,
-        };
-    }
-    const headerLead = status.nodeBestHeight !== null && status.nodeHeaderHeight !== null
-        ? status.nodeHeaderHeight - status.nodeBestHeight
-        : null;
-    if (headerLead !== null && headerLead > 0) {
-        if (headerLead <= TOLERATED_NODE_HEADER_LEAD_BLOCKS) {
-            return {
-                health: "synced",
-                message: TOLERATED_NODE_HEADER_LEAD_MESSAGE,
-            };
-        }
-        return {
-            health: "catching-up",
-            message: NODE_CATCHING_UP_MESSAGE,
-        };
-    }
-    return {
-        health: "synced",
-        message: null,
-    };
-}
-export function deriveNodeHealthForTesting(status, bitcoindHealth) {
-    return deriveNodeHealth(status, bitcoindHealth);
-}
-function deriveIndexerHealth(options) {
-    const daemonStatus = options.source === "lease"
-        ? options.daemonStatus
-        : options.observedStatus ?? options.daemonStatus;
-    const snapshotTip = options.snapshot?.tip ?? null;
-    const daemonInstanceId = options.snapshot?.daemonInstanceId ?? daemonStatus?.daemonInstanceId ?? null;
-    const snapshotSeq = options.snapshot?.snapshotSeq ?? daemonStatus?.snapshotSeq ?? null;
-    const openedAtUnixMs = options.snapshot?.openedAtUnixMs ?? null;
-    const source = daemonStatus === null && options.snapshot === null ? "none" : options.source;
-    const createResult = (health, message) => ({
-        health,
-        status: daemonStatus,
-        message,
-        snapshotTip,
-        source,
-        daemonInstanceId,
-        snapshotSeq,
-        openedAtUnixMs,
-    });
-    if (options.startupError !== null) {
-        const mapped = mapIndexerStartupError(options.startupError);
-        return createResult(mapped.health, mapped.message);
-    }
-    if (daemonStatus === null) {
-        return createResult("unavailable", "Indexer daemon is unavailable.");
-    }
-    if ((options.now - daemonStatus.heartbeatAtUnixMs) > STALE_HEARTBEAT_THRESHOLD_MS) {
-        return createResult("stale-heartbeat", "Indexer daemon heartbeat is stale.");
-    }
-    if (daemonStatus.state === "schema-mismatch") {
-        return createResult("schema-mismatch", daemonStatus.lastError ?? "Indexer daemon sqlite schema is incompatible.");
-    }
-    if (daemonStatus.state === "failed") {
-        return createResult("failed", daemonStatus.lastError ?? "Indexer daemon refresh failed.");
-    }
-    if (daemonStatus.state === "service-version-mismatch") {
-        return createResult("service-version-mismatch", "Indexer daemon service API is incompatible.");
-    }
-    if (options.snapshot === null) {
-        if (daemonStatus.state === "reorging") {
-            return createResult("reorging", "Indexer daemon is replaying a reorg and refreshing the coherent snapshot.");
-        }
-        return createResult(daemonStatus.state === "catching-up" ? "catching-up" : "starting", "Indexer snapshot is not ready yet.");
-    }
-    if (daemonStatus.state === "catching-up") {
-        return createResult("catching-up", "Indexer daemon is still catching up to the managed Bitcoin tip.");
-    }
-    if (daemonStatus.state === "reorging") {
-        return createResult("reorging", "Indexer daemon is replaying a reorg and refreshing the coherent snapshot.");
-    }
-    return createResult("synced", null);
-}
-async function attachNodeStatus(options) {
-    try {
-        const probe = await probeManagedBitcoindService({
-            dataDir: options.dataDir,
-            chain: "main",
-            startHeight: 0,
-            walletRootId: options.walletRootId,
-            startupTimeoutMs: options.startupTimeoutMs,
-        });
-        if (probe.compatibility !== "compatible" && probe.compatibility !== "unreachable") {
-            return {
-                handle: null,
-                rpc: null,
-                status: null,
-                observedStatus: probe.status,
-                error: probe.error,
-            };
-        }
-        const genesis = await loadBundledGenesisParameters();
-        const handle = await attachOrStartManagedBitcoindService({
-            dataDir: options.dataDir,
-            chain: "main",
-            startHeight: resolveCogcoinProcessingStartHeight(genesis),
-            walletRootId: options.walletRootId,
-            startupTimeoutMs: options.startupTimeoutMs,
-        });
-        const rpc = createRpcClient(handle.rpc);
-        const [chainInfo, serviceStatus] = await Promise.all([
-            rpc.getBlockchainInfo(),
-            handle.refreshServiceStatus?.(),
-        ]);
-        const status = {
-            ready: true,
-            chain: chainInfo.chain,
-            pid: handle.pid,
-            walletRootId: handle.walletRootId ?? null,
-            nodeBestHeight: chainInfo.blocks,
-            nodeBestHashHex: chainInfo.bestblockhash,
-            nodeHeaderHeight: chainInfo.headers,
-            serviceUpdatedAtUnixMs: serviceStatus?.updatedAtUnixMs ?? null,
-            serviceStatus: serviceStatus ?? null,
-            walletReplica: serviceStatus?.walletReplica ?? null,
-            walletReplicaMessage: serviceStatus?.walletReplica?.message ?? null,
-        };
-        return {
-            handle,
-            rpc,
-            status,
-            observedStatus: serviceStatus ?? null,
-            error: null,
-        };
-    }
-    catch (error) {
-        return {
-            handle: null,
-            rpc: null,
-            status: null,
-            observedStatus: null,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
 async function readFundingSpendableSats(options) {
     if (options.state === null || options.rpc === null) {
         return null;
@@ -524,105 +245,26 @@ export async function openWalletReadContext(options) {
         paths: options.paths,
     });
     const walletRootId = localState.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const node = await attachNodeStatus({
+    const managedServices = await openManagedWalletReadServiceBundle({
         dataDir: options.dataDir,
+        databasePath: options.databasePath,
         walletRootId,
+        localState,
         startupTimeoutMs,
-    });
-    if (localState.state !== null && node.status !== null) {
-        const verifiedReplica = await verifyManagedCoreWalletReplica(localState.state, options.dataDir, {
-            nodeHandle: node.handle ?? undefined,
-        });
-        node.status = {
-            ...node.status,
-            walletReplica: verifiedReplica,
-            walletReplicaMessage: verifiedReplica.message ?? null,
-        };
-    }
-    const bitcoind = deriveBitcoindHealth({
-        status: node.observedStatus,
-        nodeStatus: node.status,
-        startupError: node.error,
-    });
-    const nodeDerived = deriveNodeHealth(node.status, bitcoind.health);
-    let daemonClient = null;
-    let daemonStatus = null;
-    let observedDaemonStatus = null;
-    let snapshot = null;
-    let indexerSource = "none";
-    let daemonError = null;
-    try {
-        const probe = await probeIndexerDaemon({
-            dataDir: options.dataDir,
-            walletRootId,
-        });
-        if (probe.compatibility === "compatible" || probe.compatibility === "unreachable") {
-            await probe.client?.close().catch(() => undefined);
-            daemonClient = await attachOrStartIndexerDaemon({
-                dataDir: options.dataDir,
-                databasePath: options.databasePath,
-                walletRootId,
-                startupTimeoutMs,
-                ensureBackgroundFollow: true,
-                expectedBinaryVersion: expectedIndexerBinaryVersion,
-            });
-        }
-        else {
-            observedDaemonStatus = probe.status;
-            indexerSource = probe.status === null ? "none" : "probe";
-            daemonError = probe.error;
-        }
-        if (daemonClient !== null) {
-            const lease = await readSnapshotWithRetry(daemonClient, walletRootId);
-            daemonStatus = lease.status;
-            observedDaemonStatus = lease.status;
-            snapshot = {
-                tip: lease.payload.tip,
-                state: deserializeIndexerState(Buffer.from(lease.payload.stateBase64, "base64")),
-                source: "lease",
-                daemonInstanceId: lease.payload.daemonInstanceId,
-                snapshotSeq: lease.payload.snapshotSeq,
-                openedAtUnixMs: lease.payload.openedAtUnixMs,
-            };
-            indexerSource = "lease";
-        }
-    }
-    catch (error) {
-        daemonError = error instanceof Error ? error.message : String(error);
-        if (daemonError === INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED) {
-            await daemonClient?.close().catch(() => undefined);
-            await node.handle?.stop().catch(() => undefined);
-            throw error;
-        }
-        if (observedDaemonStatus === null) {
-            observedDaemonStatus = await readObservedIndexerDaemonStatus({
-                dataDir: options.dataDir,
-                walletRootId,
-            }).catch(() => null);
-            if (observedDaemonStatus !== null) {
-                indexerSource = "status-file";
-            }
-        }
-    }
-    const indexer = deriveIndexerHealth({
-        daemonStatus,
-        observedStatus: observedDaemonStatus,
-        snapshot,
-        source: indexerSource,
+        expectedIndexerBinaryVersion,
         now,
-        startupError: daemonError,
     });
     const fundingSpendableSats = await readFundingSpendableSats({
         state: localState.state,
-        rpc: node.rpc,
+        rpc: managedServices.node.rpc,
     });
     const mining = await inspectMiningControlPlane({
         provider: options.secretProvider,
         localState,
-        bitcoind,
-        nodeStatus: node.status,
-        nodeHealth: nodeDerived.health,
-        indexer,
+        bitcoind: managedServices.bitcoind,
+        nodeStatus: managedServices.node.status,
+        nodeHealth: managedServices.nodeHealth,
+        indexer: managedServices.indexer,
         nowUnixMs: now,
         paths: options.paths,
     });
@@ -630,20 +272,19 @@ export async function openWalletReadContext(options) {
         dataDir: options.dataDir,
         databasePath: options.databasePath,
         localState,
-        bitcoind,
-        nodeStatus: node.status,
-        nodeHealth: nodeDerived.health,
-        nodeMessage: nodeDerived.message,
-        indexer,
-        snapshot,
+        bitcoind: managedServices.bitcoind,
+        nodeStatus: managedServices.node.status,
+        nodeHealth: managedServices.nodeHealth,
+        nodeMessage: managedServices.nodeMessage,
+        indexer: managedServices.indexer,
+        snapshot: managedServices.snapshot,
         model: localState.state === null
             ? null
-            : createWalletReadModel(localState.state, snapshot),
+            : createWalletReadModel(localState.state, managedServices.snapshot),
         fundingSpendableSats,
         mining,
         async close() {
-            await daemonClient?.close().catch(() => undefined);
-            await node.handle?.stop().catch(() => undefined);
+            await managedServices.close();
         },
     };
 }

package/dist/wallet/read/managed-services.d.ts

@@ -0,0 +1,33 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, type IndexerDaemonClient } from "../../bitcoind/indexer-daemon.js";
+import type { ManagedWalletReadServiceBundle } from "../../bitcoind/managed-runtime/types.js";
+import { createRpcClient } from "../../bitcoind/node.js";
+import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
+import type { ManagedBitcoindNodeHandle } from "../../bitcoind/types.js";
+import { verifyManagedCoreWalletReplica } from "../lifecycle.js";
+import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletServiceHealth } from "./types.js";
+type ManagedWalletReadServiceDeps = {
+    loadBundledGenesisParameters: typeof loadBundledGenesisParameters;
+    probeManagedBitcoindService: typeof probeManagedBitcoindService;
+    attachOrStartManagedBitcoindService: typeof attachOrStartManagedBitcoindService;
+    createRpcClient: typeof createRpcClient;
+    verifyManagedCoreWalletReplica: typeof verifyManagedCoreWalletReplica;
+    probeIndexerDaemon: typeof probeIndexerDaemon;
+    attachOrStartIndexerDaemon: typeof attachOrStartIndexerDaemon;
+    readSnapshotWithRetry: typeof readSnapshotWithRetry;
+    readObservedIndexerDaemonStatus: typeof readObservedIndexerDaemonStatus;
+};
+export declare function deriveNodeHealthForTesting(status: WalletNodeStatus | null, bitcoindHealth: WalletBitcoindStatus["health"]): {
+    health: WalletServiceHealth;
+    message: string | null;
+};
+export declare function openManagedWalletReadServiceBundle(options: {
+    dataDir: string;
+    databasePath: string;
+    walletRootId: string;
+    localState: WalletLocalStateStatus;
+    startupTimeoutMs: number;
+    expectedIndexerBinaryVersion: string | null;
+    now: number;
+}, dependencies?: ManagedWalletReadServiceDeps): Promise<ManagedWalletReadServiceBundle<ManagedBitcoindNodeHandle, ReturnType<typeof createRpcClient>, IndexerDaemonClient>>;
+export {};