@cogcoin/client 1.2.3 → 1.2.5

package/dist/passive-status.js

@@ -1,8 +1,10 @@
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { resolveManagedServicePaths } from "./bitcoind/service-paths.js";
 import { openReadonlySqliteDatabase } from "./sqlite/driver.js";
 import { loadLatestCheckpoint } from "./sqlite/checkpoints.js";
 import { loadTipMeta } from "./sqlite/tip-meta.js";
+import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, } from "./wallet/state/storage.js";
 function fileExists(path) {
     return stat(path).then(() => true, () => false);
 }
@@ -21,6 +23,193 @@ function readBootstrapState(raw) {
         updatedAt: parsed.updatedAt ?? null,
     };
 }
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isMissingFileError(error) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === "ENOENT";
+}
+async function inspectWalletStatus(runtimePaths) {
+    if (runtimePaths === undefined) {
+        return {
+            walletRootId: null,
+            source: "none",
+            error: null,
+        };
+    }
+    try {
+        const raw = await loadRawWalletStateEnvelope({
+            primaryPath: runtimePaths.walletStatePath,
+            backupPath: runtimePaths.walletStateBackupPath,
+        });
+        if (raw === null) {
+            return {
+                walletRootId: null,
+                source: "none",
+                error: null,
+            };
+        }
+        return {
+            walletRootId: extractWalletRootIdHintFromWalletStateEnvelope(raw.envelope),
+            source: "wallet-state",
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            walletRootId: null,
+            source: "unreadable",
+            error: formatUnknownError(error),
+        };
+    }
+}
+async function readRuntimeStatusFile(statusPath) {
+    if (statusPath === null) {
+        return {
+            status: null,
+            present: false,
+            error: null,
+        };
+    }
+    try {
+        return {
+            status: JSON.parse(await readFile(statusPath, "utf8")),
+            present: true,
+            error: null,
+        };
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return {
+                status: null,
+                present: false,
+                error: null,
+            };
+        }
+        return {
+            status: null,
+            present: true,
+            error: formatUnknownError(error),
+        };
+    }
+}
+function emptyManagedBitcoindStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        state: null,
+        processId: null,
+        walletRootId: null,
+        heartbeatAtUnixMs: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        error,
+    };
+}
+function emptyIndexerStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        state: null,
+        processId: null,
+        walletRootId: null,
+        coreBestHeight: null,
+        appliedTipHeight: null,
+        appliedTipHash: null,
+        heartbeatAtUnixMs: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        error,
+    };
+}
+function emptyMiningStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        runMode: null,
+        miningState: null,
+        currentPhase: null,
+        backgroundWorkerPid: null,
+        backgroundWorkerHealth: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        note: null,
+        error,
+    };
+}
+function resolvePassiveServiceStatusPaths(bitcoinDataDir, runtimePaths, walletRootId) {
+    if (walletRootId !== null) {
+        const servicePaths = resolveManagedServicePaths(bitcoinDataDir, walletRootId);
+        return {
+            bitcoindStatusPath: servicePaths.bitcoindStatusPath,
+            indexerStatusPath: servicePaths.indexerDaemonStatusPath,
+            miningStatusPath: runtimePaths?.miningStatusPath ?? null,
+        };
+    }
+    return {
+        bitcoindStatusPath: runtimePaths?.bitcoindStatusPath ?? null,
+        indexerStatusPath: runtimePaths?.indexerStatusPath ?? null,
+        miningStatusPath: runtimePaths?.miningStatusPath ?? null,
+    };
+}
+async function inspectManagedBitcoindStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyManagedBitcoindStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        state: result.status.state ?? null,
+        processId: result.status.processId ?? null,
+        walletRootId: result.status.walletRootId ?? null,
+        heartbeatAtUnixMs: result.status.heartbeatAtUnixMs ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        error: null,
+    };
+}
+async function inspectIndexerStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyIndexerStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        state: result.status.state ?? null,
+        processId: result.status.processId ?? null,
+        walletRootId: result.status.walletRootId ?? null,
+        coreBestHeight: result.status.coreBestHeight ?? null,
+        appliedTipHeight: result.status.appliedTipHeight ?? null,
+        appliedTipHash: result.status.appliedTipHash ?? null,
+        heartbeatAtUnixMs: result.status.heartbeatAtUnixMs ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        error: null,
+    };
+}
+async function inspectMiningStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyMiningStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        runMode: result.status.runMode ?? null,
+        miningState: result.status.miningState ?? null,
+        currentPhase: result.status.currentPhase ?? null,
+        backgroundWorkerPid: result.status.backgroundWorkerPid ?? null,
+        backgroundWorkerHealth: result.status.backgroundWorkerHealth ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        note: result.status.note ?? null,
+        error: null,
+    };
+}
 async function inspectSqliteStore(dbPath) {
     const database = await openReadonlySqliteDatabase(dbPath);
     try {
@@ -50,9 +239,14 @@ async function inspectSqliteStore(dbPath) {
         await database.close();
     }
 }
-export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
+export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir, runtimePaths) {
     const storeExists = await fileExists(dbPath);
     const bootstrapPath = join(bitcoinDataDir, "bootstrap", "state.json");
+    const wallet = await inspectWalletStatus(runtimePaths);
+    const statusPaths = resolvePassiveServiceStatusPaths(bitcoinDataDir, runtimePaths, wallet.walletRootId);
+    const managedBitcoind = await inspectManagedBitcoindStatus(statusPaths.bitcoindStatusPath);
+    const indexer = await inspectIndexerStatus(statusPaths.indexerStatusPath);
+    const mining = await inspectMiningStatus(statusPaths.miningStatusPath);
     let bootstrap = null;
     try {
         bootstrap = readBootstrapState(await readFile(bootstrapPath, "utf8"));
@@ -64,11 +258,15 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: false,
             storeExists: false,
             indexedTip: null,
             latestCheckpoint: null,
             bootstrap,
+            managedBitcoind,
+            indexer,
+            mining,
             storeError: null,
         };
     }
@@ -77,11 +275,15 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: store.storeInitialized,
             storeExists: true,
             indexedTip: store.indexedTip,
             latestCheckpoint: store.latestCheckpoint,
             bootstrap,
+            managedBitcoind,
+            indexer,
+            mining,
             storeError: null,
         };
     }
@@ -89,12 +291,16 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: false,
             storeExists: true,
             indexedTip: null,
             latestCheckpoint: null,
             bootstrap,
-            storeError: error instanceof Error ? error.message : String(error),
+            managedBitcoind,
+            indexer,
+            mining,
+            storeError: formatUnknownError(error),
         };
     }
 }

package/dist/wallet/lifecycle/context.js

@@ -47,6 +47,7 @@ export function resolveWalletRepairContext(options) {
         attachIndexerDaemon: options.attachIndexerDaemon ?? attachOrStartIndexerDaemon,
         probeIndexerDaemon: options.probeIndexerDaemon ?? probeIndexerDaemon,
         requestMiningPreemption: options.requestMiningPreemption,
+        progress: options.progress ?? (() => undefined),
     };
 }
 export async function acquireWalletControlLock(paths, purpose) {

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

@@ -4,7 +4,7 @@ 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 { clearManagedBitcoindArtifactsForDataDir, isManagedBitcoindRpcUnavailableError, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
+import { clearManagedBitcoindArtifactsForDataDir, isManagedBitcoindRpcUnavailableError, isManagedBitcoindStartupWarmupError, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, reportRepairProgress, waitForProcessExit, } from "./repair-runtime.js";
 export async function repairManagedBitcoindStage(options) {
     let state = options.state;
     let repairStateNeedsPersist = options.repairStateNeedsPersist;
@@ -18,19 +18,36 @@ export async function repairManagedBitcoindStage(options) {
         error: null,
     };
     let bitcoindPostRepairHealth = "unavailable";
+    const rpcReadyProgress = async (event) => {
+        await reportRepairProgress(options.context, event.code, event.message);
+    };
     const bitcoindLock = await acquireFileLock(options.servicePaths.bitcoindLockPath, {
         purpose: "managed-bitcoind-repair",
         walletRootId: state.walletRootId,
         dataDir: options.context.dataDir,
     });
     try {
+        await reportRepairProgress(options.context, "bitcoind-check", "Checking managed bitcoind...");
         initialBitcoindProbe = await options.context.probeBitcoindService({
             dataDir: options.context.dataDir,
             chain: "main",
             startHeight: 0,
             walletRootId: state.walletRootId,
+            rpcReadyProgress,
         });
         bitcoindCompatibilityIssue = mapBitcoindCompatibilityToRepairIssue(initialBitcoindProbe.compatibility);
+        if (initialBitcoindProbe.compatibility === "starting") {
+            await reportRepairProgress(options.context, "bitcoind-starting", "Bitcoin Core is loading the block index; leaving managed bitcoind running.");
+            return {
+                state,
+                repairStateNeedsPersist,
+                recreatedManagedCoreWallet,
+                bitcoindServiceAction,
+                bitcoindCompatibilityIssue,
+                managedCoreReplicaAction,
+                bitcoindPostRepairHealth: "starting",
+            };
+        }
         if (initialBitcoindProbe.compatibility === "service-version-mismatch"
             || initialBitcoindProbe.compatibility === "wallet-root-mismatch"
             || initialBitcoindProbe.compatibility === "runtime-mismatch"
@@ -40,10 +57,14 @@ export async function repairManagedBitcoindStage(options) {
                 if (initialBitcoindProbe.compatibility !== "rawtx-zmq-missing") {
                     throw new Error("managed_bitcoind_process_id_unavailable");
                 }
+                await reportRepairProgress(options.context, "bitcoind-clear-stale-rawtx", "Clearing stale managed bitcoind runtime missing rawtx ZMQ...");
                 await clearManagedBitcoindArtifactsForDataDir(options.servicePaths, options.context.dataDir);
                 bitcoindServiceAction = "restarted-missing-rawtx-zmq";
             }
             else {
+                await reportRepairProgress(options.context, "bitcoind-stop-incompatible", initialBitcoindProbe.compatibility === "rawtx-zmq-missing"
+                    ? "Stopping stale managed bitcoind missing rawtx ZMQ..."
+                    : "Stopping incompatible managed bitcoind service...");
                 try {
                     process.kill(processId, "SIGTERM");
                 }
@@ -53,6 +74,7 @@ export async function repairManagedBitcoindStage(options) {
                     }
                 }
                 await waitForProcessExit(processId, 15_000, "managed_bitcoind_stop_timeout");
+                await reportRepairProgress(options.context, "bitcoind-clear-artifacts", "Clearing managed bitcoind runtime artifacts...");
                 await clearManagedBitcoindArtifactsForDataDir(options.servicePaths, options.context.dataDir);
                 bitcoindServiceAction = initialBitcoindProbe.compatibility === "rawtx-zmq-missing"
                     ? "restarted-missing-rawtx-zmq"
@@ -68,6 +90,7 @@ export async function repairManagedBitcoindStage(options) {
                 options.servicePaths.bitcoindWalletStatusPath,
             ].map(pathExists));
             if (hasStaleArtifacts.some(Boolean)) {
+                await reportRepairProgress(options.context, "bitcoind-clear-stale", "Clearing stale managed bitcoind artifacts...");
                 await clearManagedBitcoindArtifactsForDataDir(options.servicePaths, options.context.dataDir);
                 bitcoindServiceAction = "cleared-stale-artifacts";
             }
@@ -83,12 +106,17 @@ export async function repairManagedBitcoindStage(options) {
         let bitcoindHandle = null;
         let handleClosed = false;
         try {
+            await reportRepairProgress(options.context, attachAttempt === 0 ? "bitcoind-start" : "bitcoind-retry-start", bitcoindServiceAction === "none"
+                ? "Attaching to managed bitcoind..."
+                : "Starting managed bitcoind with current ZMQ config...");
             bitcoindHandle = await options.context.attachService({
                 dataDir: options.context.dataDir,
                 chain: "main",
                 startHeight: 0,
                 walletRootId: state.walletRootId,
+                rpcReadyProgress,
             });
+            await reportRepairProgress(options.context, "bitcoind-normalize-wallet", "Checking managed Bitcoin wallet state...");
             const rpc = options.context.rpcFactory(bitcoindHandle.rpc);
             const normalizedDescriptorState = await normalizeWalletDescriptorState(state, rpc);
             if (normalizedDescriptorState.changed) {
@@ -116,6 +144,7 @@ export async function repairManagedBitcoindStage(options) {
                 rpcFactory: options.context.rpcFactory,
             });
             if (replica.proofStatus !== "ready") {
+                await reportRepairProgress(options.context, "bitcoind-recreate-replica", "Recreating managed Core wallet replica...");
                 state = await recreateManagedCoreWalletReplica(state, options.context.provider, options.context.paths, options.context.dataDir, options.context.nowUnixMs, {
                     attachService: options.context.attachService,
                     rpcFactory: options.context.rpcFactory,
@@ -129,6 +158,7 @@ export async function repairManagedBitcoindStage(options) {
                     rpcFactory: options.context.rpcFactory,
                 });
             }
+            await reportRepairProgress(options.context, "bitcoind-final-health", "Checking managed bitcoind post-repair health...");
             const finalBitcoindStatus = await bitcoindHandle.refreshServiceStatus?.() ?? null;
             const chainInfo = await rpc.getBlockchainInfo();
             bitcoindPostRepairHealth = mapBitcoindRepairHealth({
@@ -150,6 +180,18 @@ export async function repairManagedBitcoindStage(options) {
             };
         }
         catch (error) {
+            if (isManagedBitcoindStartupWarmupError(error)) {
+                await reportRepairProgress(options.context, "bitcoind-starting", "Bitcoin Core is loading the block index; leaving managed bitcoind running.");
+                return {
+                    state,
+                    repairStateNeedsPersist,
+                    recreatedManagedCoreWallet,
+                    bitcoindServiceAction,
+                    bitcoindCompatibilityIssue,
+                    managedCoreReplicaAction,
+                    bitcoindPostRepairHealth: "starting",
+                };
+            }
             if (bitcoindHandle !== null) {
                 await bitcoindHandle.stop?.().catch(() => undefined);
                 handleClosed = true;
@@ -161,6 +203,7 @@ export async function repairManagedBitcoindStage(options) {
                     dataDir: options.context.dataDir,
                 });
                 try {
+                    await reportRepairProgress(options.context, "bitcoind-clear-stale-rpc", "Clearing stale managed bitcoind RPC artifacts...");
                     await clearManagedBitcoindArtifactsForDataDir(options.servicePaths, options.context.dataDir);
                 }
                 finally {

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

@@ -2,7 +2,7 @@ import { attachOrStartIndexerDaemon, probeIndexerDaemon } from "../../bitcoind/i
 import { probeManagedBitcoindService } from "../../bitcoind/service.js";
 import { resolveManagedServicePaths } from "../../bitcoind/service-paths.js";
 import type { ManagedBitcoindServiceStatus } from "../../bitcoind/types.js";
-import type { WalletRepairResult } from "./types.js";
+import type { WalletRepairContext, WalletRepairResult } from "./types.js";
 export declare function ensureIndexerDatabaseHealthy(options: {
     databasePath: string;
     dataDir: string;
@@ -18,6 +18,8 @@ export declare function mapBitcoindRepairHealth(options: {
         proofStatus?: "missing" | "mismatch" | "ready" | "not-proven";
     } | null;
 }): WalletRepairResult["bitcoindPostRepairHealth"];
+export declare function reportRepairProgress(context: Pick<WalletRepairContext, "progress">, code: string, message: string): Promise<void>;
+export declare function isManagedBitcoindStartupWarmupError(error: unknown): boolean;
 export declare function verifyIndexerPostRepairHealth(options: {
     daemon: Awaited<ReturnType<typeof attachOrStartIndexerDaemon>>;
     probeIndexerDaemon: typeof probeIndexerDaemon;

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

@@ -93,6 +93,18 @@ export function mapBitcoindRepairHealth(options) {
     }
     return "ready";
 }
+export async function reportRepairProgress(context, code, message) {
+    await context.progress({ code, message });
+}
+export function isManagedBitcoindStartupWarmupError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message === "managed_bitcoind_service_starting"
+        || message === "bitcoind_rpc_timeout"
+        || message === "bitcoind_cookie_timeout"
+        || /^bitcoind_rpc_[^_]+_-28(?:_|$)/.test(message)
+        || message.startsWith("The managed Bitcoin RPC cookie file is unavailable at ")
+        || message.startsWith("The managed Bitcoin RPC cookie file could not be read at ");
+}
 function mapLeaseStateToRepairHealth(state) {
     switch (state) {
         case "synced":

package/dist/wallet/lifecycle/repair.js

@@ -6,7 +6,7 @@ import { acquireWalletControlLock, resolveWalletRepairContext, } from "./context
 import { repairManagedBitcoindStage } from "./repair-bitcoind.js";
 import { repairManagedIndexerStage } from "./repair-indexer.js";
 import { applyRepairStoppedMiningState, cleanupMiningForRepair, persistRepairState, resumeBackgroundMiningAfterRepair, } from "./repair-mining.js";
-import { clearOrphanedRepairLocks, ensureIndexerDatabaseHealthy, } from "./repair-runtime.js";
+import { clearOrphanedRepairLocks, ensureIndexerDatabaseHealthy, reportRepairProgress, } from "./repair-runtime.js";
 export async function repairWallet(options) {
     const context = resolveWalletRepairContext(options);
     await clearOrphanedRepairLocks([
@@ -17,6 +17,7 @@ export async function repairWallet(options) {
     try {
         let loaded;
         try {
+            await reportRepairProgress(context, "wallet-check", "Checking wallet state...");
             loaded = await loadWalletState({
                 primaryPath: context.paths.walletStatePath,
                 backupPath: context.paths.walletStateBackupPath,
@@ -31,10 +32,12 @@ export async function repairWallet(options) {
         let repairedState = loaded.state;
         let repairStateNeedsPersist = false;
         const servicePaths = resolveManagedServicePaths(context.dataDir, repairedState.walletRootId);
+        await reportRepairProgress(context, "lock-cleanup", "Checking repair locks...");
         await clearOrphanedRepairLocks([
             servicePaths.bitcoindLockPath,
             servicePaths.indexerDaemonLockPath,
         ]);
+        await reportRepairProgress(context, "mining-cleanup", "Checking mining runtime...");
         const preRepairMiningRuntime = await loadMiningRuntimeStatus(context.paths.miningStatusPath).catch(() => null);
         const miningCleanup = await cleanupMiningForRepair({
             paths: context.paths,
@@ -48,6 +51,7 @@ export async function repairWallet(options) {
             repairStateNeedsPersist = true;
         }
         if (!context.assumeYes) {
+            await reportRepairProgress(context, "indexer-database-check", "Checking local indexer database...");
             await ensureIndexerDatabaseHealthy({
                 databasePath: context.databasePath,
                 dataDir: context.dataDir,
@@ -64,7 +68,12 @@ export async function repairWallet(options) {
         });
         repairedState = bitcoindStage.state;
         repairStateNeedsPersist = bitcoindStage.repairStateNeedsPersist;
+        const repairNotes = [];
+        if (bitcoindStage.bitcoindPostRepairHealth === "starting") {
+            repairNotes.push("Managed bitcoind was restarted and is still loading the block index; rerun mining after it reaches ready.");
+        }
         if (recoveredFromBackup) {
+            await reportRepairProgress(context, "wallet-state-persist", "Persisting repaired wallet state...");
             repairedState = await persistRepairState({
                 state: repairedState,
                 provider: context.provider,
@@ -75,6 +84,7 @@ export async function repairWallet(options) {
             repairStateNeedsPersist = false;
         }
         else if (repairStateNeedsPersist) {
+            await reportRepairProgress(context, "wallet-state-persist", "Persisting repaired wallet state...");
             repairedState = await persistRepairState({
                 state: repairedState,
                 provider: context.provider,
@@ -83,11 +93,25 @@ export async function repairWallet(options) {
             });
             repairStateNeedsPersist = false;
         }
-        const indexerStage = await repairManagedIndexerStage({
-            context,
-            servicePaths,
-            state: repairedState,
-        });
+        const indexerStage = bitcoindStage.bitcoindPostRepairHealth === "starting"
+            ? {
+                resetIndexerDatabase: false,
+                indexerDaemonAction: "none",
+                indexerCompatibilityIssue: "none",
+                indexerPostRepairHealth: "starting",
+            }
+            : await (async () => {
+                await reportRepairProgress(context, "indexer-check", "Checking indexer...");
+                return repairManagedIndexerStage({
+                    context,
+                    servicePaths,
+                    state: repairedState,
+                });
+            })();
+        if (indexerStage.resetIndexerDatabase) {
+            repairNotes.push("Indexer artifacts were reset and may still be catching up.");
+        }
+        await reportRepairProgress(context, "mining-resume", "Checking whether mining should resume...");
         const miningResume = await resumeBackgroundMiningAfterRepair({
             miningPreRepairRunMode,
             provider: context.provider,
@@ -113,9 +137,7 @@ export async function repairWallet(options) {
             miningResumeAction: miningResume.miningResumeAction,
             miningPostRepairRunMode: miningResume.miningPostRepairRunMode,
             miningResumeError: miningResume.miningResumeError,
-            note: indexerStage.resetIndexerDatabase
-                ? "Indexer artifacts were reset and may still be catching up."
-                : null,
+            note: repairNotes.length > 0 ? repairNotes.join(" ") : null,
         };
     }
     finally {

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

@@ -49,6 +49,11 @@ export interface WalletRepairResult {
     miningResumeError: string | null;
     note: string | null;
 }
+export interface WalletRepairProgressEvent {
+    code: string;
+    message: string;
+}
+export type WalletRepairProgressReporter = (event: WalletRepairProgressEvent) => void | Promise<void>;
 export interface WalletLifecycleRpcClient {
     getDescriptorInfo(descriptor: string): Promise<{
         descriptor: string;
@@ -126,6 +131,7 @@ export interface WalletRepairDependencies extends WalletManagedCoreDependencies
     attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
     probeIndexerDaemon?: typeof probeIndexerDaemon;
     requestMiningPreemption?: typeof requestMiningGenerationPreemption;
+    progress?: WalletRepairProgressReporter;
 }
 export interface WalletRepairContext extends WalletManagedCoreContext {
     dataDir: string;
@@ -135,6 +141,7 @@ export interface WalletRepairContext extends WalletManagedCoreContext {
     attachIndexerDaemon: NonNullable<WalletRepairDependencies["attachIndexerDaemon"]>;
     probeIndexerDaemon: NonNullable<WalletRepairDependencies["probeIndexerDaemon"]>;
     requestMiningPreemption?: WalletRepairDependencies["requestMiningPreemption"];
+    progress: WalletRepairProgressReporter;
 }
 export interface WalletBitcoindRepairStageResult {
     state: WalletStateV1;

package/dist/wallet/mining/competitiveness.js

@@ -673,7 +673,7 @@ export async function runCompetitivenessGate(options) {
         });
         options.throwIfStopping?.();
         const txid = visibleTxids[index];
-        const context = cacheState.rawTxContexts.get(txid);
+        const context = rawTxContexts.get(txid);
         const mempoolEntry = mempoolEntries[txid];
         if (context === undefined || context.payload === null || context.senderScriptHex === null || mempoolEntry === undefined) {
             continue;
@@ -685,7 +685,7 @@ export async function runCompetitivenessGate(options) {
         const overlayDomain = await resolveOverlayAuthorizedMiningDomain({
             readContext: options.readContext,
             txid,
-            txContexts: cacheState.rawTxContexts,
+            txContexts: rawTxContexts,
             domainId: decoded.domainId,
             senderScriptHex: context.senderScriptHex,
         });

package/dist/wallet/mining/lifecycle.js

@@ -159,6 +159,10 @@ export async function handleRecoverableMiningBitcoindFailure(options) {
             rememberMiningBitcoindRecoveryIdentity(options.loopState, probe.status);
             options.loopState.bitcoinRecoveryFirstUnreachableAtUnixMs = null;
         }
+        else if (probe.compatibility === "starting") {
+            rememberMiningBitcoindRecoveryIdentity(options.loopState, probe.status);
+            options.loopState.bitcoinRecoveryFirstUnreachableAtUnixMs = null;
+        }
         else if (probe.compatibility === "unreachable") {
             const identityChanged = rememberMiningBitcoindRecoveryIdentity(options.loopState, probe.status);
             const livePid = isMiningBitcoindRecoveryPidAlive(probe.status?.processId ?? null);