@cogcoin/client 1.1.5 → 1.1.7

package/dist/wallet/lifecycle/repair-bitcoind.js

@@ -0,0 +1,142 @@
+import { normalizeWalletDescriptorState } from "../descriptor-normalization.js";
+import { acquireFileLock } from "../fs/lock.js";
+import { persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
+import { createWalletSecretReference } from "../state/provider.js";
+import { recreateManagedCoreWalletReplica, verifyManagedCoreWalletReplica } from "./managed-core.js";
+import { pathExists } from "./context.js";
+import { clearManagedBitcoindArtifacts, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
+export async function repairManagedBitcoindStage(options) {
+    let state = options.state;
+    let repairStateNeedsPersist = options.repairStateNeedsPersist;
+    let bitcoindServiceAction = "none";
+    let bitcoindCompatibilityIssue = "none";
+    let managedCoreReplicaAction = "none";
+    let recreatedManagedCoreWallet = false;
+    let initialBitcoindProbe = {
+        compatibility: "unreachable",
+        status: null,
+        error: null,
+    };
+    let bitcoindPostRepairHealth = "unavailable";
+    const bitcoindLock = await acquireFileLock(options.servicePaths.bitcoindLockPath, {
+        purpose: "managed-bitcoind-repair",
+        walletRootId: state.walletRootId,
+        dataDir: options.context.dataDir,
+    });
+    try {
+        initialBitcoindProbe = await options.context.probeBitcoindService({
+            dataDir: options.context.dataDir,
+            chain: "main",
+            startHeight: 0,
+            walletRootId: state.walletRootId,
+        });
+        bitcoindCompatibilityIssue = mapBitcoindCompatibilityToRepairIssue(initialBitcoindProbe.compatibility);
+        if (initialBitcoindProbe.compatibility === "service-version-mismatch"
+            || initialBitcoindProbe.compatibility === "wallet-root-mismatch"
+            || initialBitcoindProbe.compatibility === "runtime-mismatch") {
+            const processId = initialBitcoindProbe.status?.processId ?? null;
+            if (processId === null) {
+                throw new Error("managed_bitcoind_process_id_unavailable");
+            }
+            try {
+                process.kill(processId, "SIGTERM");
+            }
+            catch (error) {
+                if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                    throw error;
+                }
+            }
+            await waitForProcessExit(processId, 15_000, "managed_bitcoind_stop_timeout");
+            await clearManagedBitcoindArtifacts(options.servicePaths);
+            bitcoindServiceAction = "stopped-incompatible-service";
+        }
+        else if (initialBitcoindProbe.compatibility === "unreachable") {
+            const hasStaleArtifacts = await Promise.all([
+                options.servicePaths.bitcoindStatusPath,
+                options.servicePaths.bitcoindPidPath,
+                options.servicePaths.bitcoindReadyPath,
+                options.servicePaths.bitcoindWalletStatusPath,
+            ].map(pathExists));
+            if (hasStaleArtifacts.some(Boolean)) {
+                await clearManagedBitcoindArtifacts(options.servicePaths);
+                bitcoindServiceAction = "cleared-stale-artifacts";
+            }
+        }
+        else if (initialBitcoindProbe.compatibility === "protocol-error") {
+            throw new Error(initialBitcoindProbe.error ?? "managed_bitcoind_protocol_error");
+        }
+    }
+    finally {
+        await bitcoindLock.release();
+    }
+    const bitcoindHandle = await options.context.attachService({
+        dataDir: options.context.dataDir,
+        chain: "main",
+        startHeight: 0,
+        walletRootId: state.walletRootId,
+    });
+    try {
+        const rpc = options.context.rpcFactory(bitcoindHandle.rpc);
+        const normalizedDescriptorState = await normalizeWalletDescriptorState(state, rpc);
+        if (normalizedDescriptorState.changed) {
+            state = normalizedDescriptorState.state;
+            repairStateNeedsPersist = true;
+        }
+        const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
+            state,
+            access: {
+                provider: options.context.provider,
+                secretReference: createWalletSecretReference(state.walletRootId),
+            },
+            paths: options.context.paths,
+            nowUnixMs: options.context.nowUnixMs,
+            replacePrimary: options.recoveredFromBackup && !repairStateNeedsPersist,
+            rpc,
+        });
+        state = reconciledCoinControl.state;
+        if (reconciledCoinControl.changed) {
+            repairStateNeedsPersist = false;
+        }
+        let replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
+            nodeHandle: bitcoindHandle,
+            attachService: options.context.attachService,
+            rpcFactory: options.context.rpcFactory,
+        });
+        if (replica.proofStatus !== "ready") {
+            state = await recreateManagedCoreWalletReplica(state, options.context.provider, options.context.paths, options.context.dataDir, options.context.nowUnixMs, {
+                attachService: options.context.attachService,
+                rpcFactory: options.context.rpcFactory,
+            });
+            recreatedManagedCoreWallet = true;
+            managedCoreReplicaAction = "recreated";
+            repairStateNeedsPersist = false;
+            replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
+                nodeHandle: bitcoindHandle,
+                attachService: options.context.attachService,
+                rpcFactory: options.context.rpcFactory,
+            });
+        }
+        const finalBitcoindStatus = await bitcoindHandle.refreshServiceStatus?.() ?? null;
+        const chainInfo = await rpc.getBlockchainInfo();
+        bitcoindPostRepairHealth = mapBitcoindRepairHealth({
+            serviceState: finalBitcoindStatus?.state ?? null,
+            catchingUp: chainInfo.blocks < chainInfo.headers,
+            replica,
+        });
+        if (bitcoindServiceAction === "none" && initialBitcoindProbe.compatibility === "unreachable") {
+            bitcoindServiceAction = "restarted-compatible-service";
+        }
+    }
+    finally {
+        await bitcoindHandle.stop?.().catch(() => undefined);
+    }
+    return {
+        state,
+        repairStateNeedsPersist,
+        recreatedManagedCoreWallet,
+        bitcoindServiceAction,
+        bitcoindCompatibilityIssue,
+        managedCoreReplicaAction,
+        bitcoindPostRepairHealth,
+    };
+}

package/dist/wallet/lifecycle/repair-indexer.d.ts

@@ -0,0 +1,8 @@
+import type { ManagedServicePaths } from "../../bitcoind/service-paths.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletIndexerRepairStageResult, WalletRepairContext } from "./types.js";
+export declare function repairManagedIndexerStage(options: {
+    context: WalletRepairContext;
+    servicePaths: ManagedServicePaths;
+    state: WalletStateV1;
+}): Promise<WalletIndexerRepairStageResult>;

package/dist/wallet/lifecycle/repair-indexer.js

@@ -0,0 +1,117 @@
+import { acquireFileLock } from "../fs/lock.js";
+import { pathExists } from "./context.js";
+import { clearIndexerDaemonArtifacts, ensureIndexerDatabaseHealthy, mapIndexerCompatibilityToRepairIssue, verifyIndexerPostRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
+export async function repairManagedIndexerStage(options) {
+    let indexerDaemonAction = "none";
+    let indexerCompatibilityIssue = "none";
+    let initialIndexerDaemonInstanceId = null;
+    const indexerLock = await acquireFileLock(options.servicePaths.indexerDaemonLockPath, {
+        purpose: "indexer-daemon-repair",
+        walletRootId: options.state.walletRootId,
+        dataDir: options.context.dataDir,
+        databasePath: options.context.databasePath,
+    });
+    let resetIndexerDatabase = false;
+    try {
+        const initialProbe = await options.context.probeIndexerDaemon({
+            dataDir: options.context.dataDir,
+            walletRootId: options.state.walletRootId,
+        });
+        indexerCompatibilityIssue = mapIndexerCompatibilityToRepairIssue(initialProbe.compatibility);
+        initialIndexerDaemonInstanceId = initialProbe.status?.daemonInstanceId ?? null;
+        if (initialProbe.compatibility === "compatible") {
+            await initialProbe.client?.close().catch(() => undefined);
+        }
+        else if (initialProbe.compatibility === "service-version-mismatch"
+            || initialProbe.compatibility === "wallet-root-mismatch"
+            || initialProbe.compatibility === "schema-mismatch") {
+            const processId = initialProbe.status?.processId ?? null;
+            if (processId === null) {
+                throw new Error("indexer_daemon_process_id_unavailable");
+            }
+            try {
+                process.kill(processId, "SIGTERM");
+            }
+            catch (error) {
+                if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                    throw error;
+                }
+            }
+            await waitForProcessExit(processId);
+            await clearIndexerDaemonArtifacts(options.servicePaths);
+            indexerDaemonAction = "stopped-incompatible-daemon";
+        }
+        else if (initialProbe.compatibility === "unreachable") {
+            const hasStaleArtifacts = await Promise.all([
+                options.servicePaths.indexerDaemonSocketPath,
+                options.servicePaths.indexerDaemonStatusPath,
+            ].map(pathExists));
+            if (hasStaleArtifacts.some(Boolean)) {
+                await clearIndexerDaemonArtifacts(options.servicePaths);
+                indexerDaemonAction = "cleared-stale-artifacts";
+            }
+        }
+        else {
+            throw new Error(initialProbe.error ?? "indexer_daemon_protocol_error");
+        }
+        resetIndexerDatabase = await ensureIndexerDatabaseHealthy({
+            databasePath: options.context.databasePath,
+            dataDir: options.context.dataDir,
+            walletRootId: options.state.walletRootId,
+            resetIfNeeded: options.context.assumeYes,
+        });
+    }
+    finally {
+        await indexerLock.release();
+    }
+    let preAttachIndexerDaemonInstanceId = null;
+    const preAttachProbe = await options.context.probeIndexerDaemon({
+        dataDir: options.context.dataDir,
+        walletRootId: options.state.walletRootId,
+    });
+    if (preAttachProbe.compatibility === "compatible") {
+        preAttachIndexerDaemonInstanceId = preAttachProbe.status?.daemonInstanceId ?? null;
+        await preAttachProbe.client?.close().catch(() => undefined);
+    }
+    else if (preAttachProbe.compatibility !== "unreachable") {
+        throw new Error(preAttachProbe.error ?? "indexer_daemon_protocol_error");
+    }
+    const daemon = await options.context.attachIndexerDaemon({
+        dataDir: options.context.dataDir,
+        databasePath: options.context.databasePath,
+        walletRootId: options.state.walletRootId,
+    });
+    try {
+        const { health: indexerPostRepairHealth, daemonInstanceId: postRepairDaemonInstanceId, } = await verifyIndexerPostRepairHealth({
+            daemon,
+            probeIndexerDaemon: options.context.probeIndexerDaemon,
+            dataDir: options.context.dataDir,
+            walletRootId: options.state.walletRootId,
+            nowUnixMs: options.context.nowUnixMs,
+        });
+        const restartedIndexerDaemon = indexerDaemonAction !== "none" || preAttachProbe.compatibility === "unreachable";
+        if (restartedIndexerDaemon
+            && initialIndexerDaemonInstanceId !== null
+            && postRepairDaemonInstanceId === initialIndexerDaemonInstanceId) {
+            throw new Error("indexer_daemon_repair_identity_not_rotated");
+        }
+        if (!restartedIndexerDaemon
+            && preAttachProbe.compatibility === "compatible"
+            && preAttachIndexerDaemonInstanceId !== null
+            && postRepairDaemonInstanceId !== preAttachIndexerDaemonInstanceId) {
+            throw new Error("indexer_daemon_repair_identity_changed");
+        }
+        if (indexerDaemonAction === "none" && preAttachProbe.compatibility === "unreachable") {
+            indexerDaemonAction = "restarted-compatible-daemon";
+        }
+        return {
+            resetIndexerDatabase,
+            indexerDaemonAction,
+            indexerCompatibilityIssue,
+            indexerPostRepairHealth,
+        };
+    }
+    finally {
+        await daemon.close().catch(() => undefined);
+    }
+}

package/dist/wallet/lifecycle/repair-mining.d.ts

@@ -2,8 +2,7 @@ import type { MiningRuntimeStatusV1 } from "../mining/types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletStateV1 } from "../types.js";
-import type { WalletPrompter, WalletRepairResult } from "./types.js";
-export declare function createSilentNonInteractivePrompter(): WalletPrompter;
+import type { WalletRepairResult } from "./types.js";
 export declare function applyRepairStoppedMiningState(state: WalletStateV1): WalletStateV1;
 export declare function createStoppedMiningRuntimeSnapshotForRepair(options: {
     state: WalletStateV1;
@@ -39,9 +38,6 @@ export declare function resumeBackgroundMiningAfterRepair(options: {
     repairedState: WalletStateV1;
     bitcoindPostRepairHealth: WalletRepairResult["bitcoindPostRepairHealth"];
     indexerPostRepairHealth: WalletRepairResult["indexerPostRepairHealth"];
-    dataDir: string;
-    databasePath: string;
-    startBackgroundMining?: typeof import("../mining/runner.js").startBackgroundMining;
 }): Promise<{
     miningResumeAction: WalletRepairResult["miningResumeAction"];
     miningPostRepairRunMode: WalletRepairResult["miningPostRepairRunMode"];

package/dist/wallet/lifecycle/repair-mining.js

@@ -8,15 +8,6 @@ import { normalizeMiningStateRecord } from "../mining/state.js";
 import { createWalletSecretReference } from "../state/provider.js";
 import { persistWalletStateUpdate } from "../descriptor-normalization.js";
 import { isProcessAlive, stopRecordedManagedProcess } from "./repair-runtime.js";
-export function createSilentNonInteractivePrompter() {
-    return {
-        isInteractive: false,
-        writeLine() { },
-        async prompt() {
-            return "";
-        },
-    };
-}
 export function applyRepairStoppedMiningState(state) {
     const miningState = normalizeMiningStateRecord(state.miningState);
     return {
@@ -271,34 +262,9 @@ export async function resumeBackgroundMiningAfterRepair(options) {
             miningResumeError: null,
         };
     }
-    try {
-        const startBackgroundMining = options.startBackgroundMining
-            ?? (await import("../mining/runner.js")).startBackgroundMining;
-        const resumed = await startBackgroundMining({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.provider,
-            paths: options.paths,
-            prompter: createSilentNonInteractivePrompter(),
-        });
-        if (resumed.snapshot?.runMode === "background") {
-            return {
-                miningResumeAction: "resumed-background",
-                miningPostRepairRunMode: "background",
-                miningResumeError: null,
-            };
-        }
-        return {
-            miningResumeAction: "resume-failed",
-            miningPostRepairRunMode: "stopped",
-            miningResumeError: "Background mining did not report a background runtime after repair.",
-        };
-    }
-    catch (error) {
-        return {
-            miningResumeAction: "resume-failed",
-            miningPostRepairRunMode: "stopped",
-            miningResumeError: error instanceof Error ? error.message : String(error),
-        };
-    }
+    return {
+        miningResumeAction: "skipped-background-mode-removed",
+        miningPostRepairRunMode: "stopped",
+        miningResumeError: null,
+    };
 }

package/dist/wallet/lifecycle/repair.d.ts

@@ -1,11 +1,9 @@
-import { type WalletRuntimePaths } from "../runtime.js";
-import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletRepairDependencies, WalletRepairResult } from "./types.js";
 export declare function repairWallet(options: {
     dataDir: string;
     databasePath: string;
-    provider?: WalletSecretProvider;
+    provider?: import("../state/provider.js").WalletSecretProvider;
     assumeYes?: boolean;
     nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
+    paths?: import("../runtime.js").WalletRuntimePaths;
 } & WalletRepairDependencies): Promise<WalletRepairResult>;