@cogcoin/client 1.1.4 → 1.1.6

package/dist/wallet/mining/visualizer-sync.d.ts

@@ -0,0 +1,42 @@
+import type { WalletReadContext } from "../read/index.js";
+import type { WalletStateV1 } from "../types.js";
+import type { MiningRpcClient } from "./engine-types.js";
+import type { MiningRuntimeLoopState } from "./engine-state.js";
+import type { MiningFollowVisualizerState, MiningRecentWinSummary, MiningSentenceBoardEntry } from "./visualizer.js";
+export declare function resolveSettledBoard(options: {
+    snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined;
+    snapshotTipHeight: number | null;
+    snapshotTipPreviousHashHex?: string | null;
+    nodeBestHeight: number | null;
+}): {
+    settledBlockHeight: number | null;
+    settledBoardEntries: MiningSentenceBoardEntry[];
+};
+export declare function syncMiningUiForCurrentTip(options: {
+    loopState: MiningRuntimeLoopState;
+    snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined;
+    snapshotTipHeight: number | null;
+    snapshotTipPreviousHashHex: string | null;
+    nodeBestHeight: number | null;
+    nodeBestHash: string | null;
+    recentWin: MiningRecentWinSummary | null;
+}): {
+    targetBlockHeight: number | null;
+    tipKey: string | null;
+    tipChanged: boolean;
+};
+export declare function resolveFundingDisplaySats(state: WalletStateV1, rpc: MiningRpcClient): Promise<bigint>;
+export declare function loadMiningVisibleFollowBlockTimes(options: {
+    rpc: MiningRpcClient;
+    indexedTipHeight: number | null;
+    indexedTipHashHex: string | null;
+}): Promise<Record<number, number>>;
+export declare function syncMiningVisualizerBalances(loopState: MiningRuntimeLoopState, readContext: WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+}, balanceSats: bigint | null): void;
+export declare function createIndexedMiningFollowVisualizerState(readContext: WalletReadContext): MiningFollowVisualizerState;
+export declare function syncMiningVisualizerBlockTimes(loopState: MiningRuntimeLoopState, blockTimesByHeight: Record<number, number>): void;
+export declare function findRecentMiningWin(snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined, txid: string | null, targetBlockHeight: number | null): MiningRecentWinSummary | null;

package/dist/wallet/mining/visualizer-sync.js

@@ -0,0 +1,166 @@
+import { getBalance, getBlockWinners, lookupDomainById, } from "@cogcoin/indexer/queries";
+import { displayToInternalBlockhash } from "@cogcoin/scoring";
+import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-times.js";
+import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
+import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
+import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
+function resolveSettledWinnerRequiredWords(options) {
+    const storedWords = resolveBip39WordsFromIndices(options.bip39WordIndices);
+    if (storedWords.length > 0) {
+        return storedWords;
+    }
+    if (options.snapshotTipPreviousHashHex === null
+        || options.snapshotTipPreviousHashHex === undefined
+        || !Number.isInteger(options.domainId)
+        || options.domainId <= 0) {
+        return [];
+    }
+    return resolveBip39WordsFromIndices(deriveMiningWordIndices(Buffer.from(displayToInternalBlockhash(options.snapshotTipPreviousHashHex), "hex"), options.domainId));
+}
+function fallbackSettledWinnerDomainName(domainId) {
+    return `domain-${domainId}`;
+}
+function resolveCurrentMinedBlockBoard(options) {
+    const settledBlockHeight = options.snapshotTipHeight ?? null;
+    if (settledBlockHeight === null) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries: [],
+        };
+    }
+    if (options.snapshotState === null || options.snapshotState === undefined) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries: [],
+        };
+    }
+    const settledBoardEntries = (getBlockWinners(options.snapshotState, settledBlockHeight) ?? [])
+        .slice()
+        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
+        .slice(0, 5)
+        .map((winner) => ({
+        rank: winner.rank,
+        domainName: lookupDomainById(options.snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
+        sentence: winner.sentenceText ?? "[unavailable]",
+        requiredWords: resolveSettledWinnerRequiredWords({
+            domainId: winner.domainId,
+            bip39WordIndices: winner.bip39WordIndices,
+            snapshotTipPreviousHashHex: options.snapshotTipPreviousHashHex,
+        }),
+    }));
+    return {
+        settledBlockHeight,
+        settledBoardEntries,
+    };
+}
+export function resolveSettledBoard(options) {
+    void options.nodeBestHeight;
+    return resolveCurrentMinedBlockBoard({
+        snapshotState: options.snapshotState,
+        snapshotTipHeight: options.snapshotTipHeight,
+        snapshotTipPreviousHashHex: options.snapshotTipPreviousHashHex ?? null,
+    });
+}
+function syncMiningUiSettledBoard(loopState, snapshotState, snapshotTipHeight, snapshotTipPreviousHashHex) {
+    const settledBoard = resolveCurrentMinedBlockBoard({
+        snapshotState,
+        snapshotTipHeight,
+        snapshotTipPreviousHashHex,
+    });
+    loopState.ui.settledBlockHeight = settledBoard.settledBlockHeight;
+    loopState.ui.settledBoardEntries = settledBoard.settledBoardEntries;
+}
+export function syncMiningUiForCurrentTip(options) {
+    const targetBlockHeight = options.nodeBestHeight === null
+        ? null
+        : options.nodeBestHeight + 1;
+    const tipKey = buildMiningTipKey(options.nodeBestHash, targetBlockHeight);
+    const priorTipKey = options.loopState.currentTipKey;
+    const tipChanged = tipKey !== null && tipKey !== priorTipKey;
+    if (tipKey !== priorTipKey) {
+        options.loopState.currentTipKey = tipKey;
+        resetMiningUiForTip(options.loopState, targetBlockHeight);
+        if (options.recentWin !== null) {
+            options.loopState.ui.recentWin = options.recentWin;
+        }
+    }
+    syncMiningUiSettledBoard(options.loopState, options.snapshotState, options.snapshotTipHeight, options.snapshotTipPreviousHashHex);
+    return {
+        targetBlockHeight,
+        tipKey,
+        tipChanged,
+    };
+}
+export async function resolveFundingDisplaySats(state, rpc) {
+    const utxos = await rpc.listUnspent(state.managedCoreWallet.walletName, 0);
+    return utxos.reduce((sum, entry) => {
+        if (entry.scriptPubKey !== state.funding.scriptPubKeyHex
+            || entry.spendable === false) {
+            return sum;
+        }
+        return sum + numberToSats(entry.amount);
+    }, 0n);
+}
+export async function loadMiningVisibleFollowBlockTimes(options) {
+    if (options.indexedTipHeight === null || options.indexedTipHashHex === null) {
+        return {};
+    }
+    const blockTimesByHeight = {};
+    let currentHeight = options.indexedTipHeight;
+    let currentHashHex = options.indexedTipHashHex;
+    for (let offset = 0; offset <= FOLLOW_VISIBLE_PRIOR_BLOCKS; offset += 1) {
+        if (currentHeight < 0 || currentHashHex === null) {
+            break;
+        }
+        const block = await options.rpc.getBlock(currentHashHex);
+        if (typeof block.time === "number") {
+            blockTimesByHeight[currentHeight] = block.time;
+        }
+        currentHashHex = block.previousblockhash ?? null;
+        currentHeight -= 1;
+    }
+    return blockTimesByHeight;
+}
+export function syncMiningVisualizerBalances(loopState, readContext, balanceSats) {
+    loopState.ui.fundingAddress = readContext.model?.walletAddress ?? readContext.localState.state.funding.address;
+    loopState.ui.balanceCogtoshi = readContext.snapshot === null
+        ? null
+        : getBalance(readContext.snapshot.state, readContext.localState.state.funding.scriptPubKeyHex);
+    loopState.ui.balanceSats = balanceSats;
+}
+export function createIndexedMiningFollowVisualizerState(readContext) {
+    const uiState = createEmptyMiningFollowVisualizerState();
+    const localState = readContext.localState;
+    const settledBoard = resolveCurrentMinedBlockBoard({
+        snapshotState: readContext.snapshot?.state ?? null,
+        snapshotTipHeight: readContext.snapshot?.tip?.height ?? readContext.indexer.snapshotTip?.height ?? null,
+        snapshotTipPreviousHashHex: readContext.snapshot?.tip?.previousHashHex ?? readContext.indexer.snapshotTip?.previousHashHex ?? null,
+    });
+    uiState.settledBlockHeight = settledBoard.settledBlockHeight;
+    uiState.settledBoardEntries = settledBoard.settledBoardEntries;
+    if (localState.availability === "ready" && localState.state !== null) {
+        uiState.fundingAddress = readContext.model?.walletAddress ?? localState.state.funding.address;
+    }
+    if (readContext.snapshot !== null && localState.availability === "ready" && localState.state !== null) {
+        uiState.balanceCogtoshi = getBalance(readContext.snapshot.state, localState.state.funding.scriptPubKeyHex);
+    }
+    return uiState;
+}
+export function syncMiningVisualizerBlockTimes(loopState, blockTimesByHeight) {
+    loopState.ui.visibleBlockTimesByHeight = { ...blockTimesByHeight };
+}
+export function findRecentMiningWin(snapshotState, txid, targetBlockHeight) {
+    if (snapshotState === null || snapshotState === undefined || txid === null || targetBlockHeight === null) {
+        return null;
+    }
+    const winners = getBlockWinners(snapshotState, targetBlockHeight) ?? [];
+    const winner = winners.find((entry) => entry.txidHex === txid) ?? null;
+    if (winner === null) {
+        return null;
+    }
+    return {
+        rank: winner.rank,
+        rewardCogtoshi: winner.rewardCogtoshi,
+        blockHeight: winner.height,
+    };
+}

package/dist/wallet/mining/visualizer.d.ts

@@ -25,6 +25,7 @@ export interface MiningRecentWinSummary {
 export interface MiningFollowVisualizerState {
     balanceCogtoshi: bigint | null;
     balanceSats: bigint | null;
+    fundingAddress: string | null;
     visibleBlockTimesByHeight: Record<number, number>;
     settledBlockHeight: number | null;
     settledBoardEntries: MiningSentenceBoardEntry[];

package/dist/wallet/mining/visualizer.js

@@ -1,5 +1,5 @@
 import { createBootstrapProgress } from "../../bitcoind/progress/formatting.js";
-import { normalizeInlineText, truncateLine } from "../../bitcoind/progress/formatting.js";
+import { centerLine, normalizeInlineText, truncateLine } from "../../bitcoind/progress/formatting.js";
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "../../bitcoind/progress/render-policy.js";
 import { TtyProgressRenderer } from "../../bitcoind/progress/tty-renderer.js";
@@ -125,18 +125,27 @@ function formatSentenceSlot(prefix, sentence, requiredWords, lineCount) {
     return lines;
 }
 function formatSentenceRow(entry) {
-    return formatSentenceSlot(`${entry.rank}. @${entry.domainName}: `, entry.sentence, entry.requiredWords, 2);
+    const prefix = `${entry.rank}. @${entry.domainName}: `;
+    const highlightedSentence = highlightRequiredWords(normalizeInlineText(entry.sentence), entry.requiredWords);
+    return `${prefix}${highlightedSentence}`;
 }
-function formatRequiredWordsLine(words) {
-    if (words.length === 0) {
-        return "";
+function formatSentenceBoardTitle(settledBlockHeight) {
+    return centerLine(`✎ Block #${settledBlockHeight ?? "-----"} Sentences ✎`, MINING_SENTENCE_BOARD_WRAP_WIDTH);
+}
+function formatProvisionalFundingLine(snapshot, ui) {
+    if (snapshot.currentPublishDecision === "publish-paused-insufficient-funds") {
+        const fundingAddress = normalizeInlineText(ui.fundingAddress ?? "");
+        return fundingAddress.length > 0
+            ? `Deposit BTC to ${fundingAddress} to mine.`
+            : "Deposit BTC to this wallet address to mine.";
     }
-    return `Required words: ${words.map((word) => word.toUpperCase()).join(", ")}`;
+    return "";
 }
-function formatProvisionalTxLinkLine(entry, txid) {
-    if (entry.domainName === null || entry.sentence === null || txid === null) {
+function formatProvisionalTxLinkLine(ui) {
+    if (ui.provisionalEntry.domainName === null || ui.provisionalEntry.sentence === null || ui.provisionalBroadcastTxid === null) {
         return "";
     }
+    const txid = ui.provisionalBroadcastTxid;
     const normalizedTxid = normalizeInlineText(txid);
     if (normalizedTxid.length === 0) {
         return "";
@@ -145,14 +154,23 @@ function formatProvisionalTxLinkLine(entry, txid) {
 }
 function formatProvisionalSentenceRow(entry, requiredWords) {
     if (entry.domainName === null || entry.sentence === null) {
-        return ["", "", ""];
+        return ["", ""];
+    }
+    return formatSentenceSlot(`@${entry.domainName}: `, entry.sentence, requiredWords, 2);
+}
+function formatProvisionalSectionLines(snapshot, ui) {
+    const sentenceLines = formatProvisionalSentenceRow(ui.provisionalEntry, ui.provisionalRequiredWords);
+    const fundingLine = formatProvisionalFundingLine(snapshot, ui);
+    if (fundingLine.length > 0) {
+        return [...sentenceLines, fundingLine];
     }
-    return formatSentenceSlot(`@${entry.domainName}: `, entry.sentence, requiredWords, 3);
+    return [...sentenceLines, formatProvisionalTxLinkLine(ui)];
 }
 export function createEmptyMiningFollowVisualizerState() {
     return {
         balanceCogtoshi: null,
         balanceSats: null,
+        fundingAddress: null,
         visibleBlockTimesByHeight: {},
         settledBlockHeight: null,
         settledBoardEntries: [],
@@ -185,6 +203,7 @@ function cloneMiningFollowVisualizerState(state) {
             ...state.provisionalEntry,
         },
         provisionalBroadcastTxid: state.provisionalBroadcastTxid,
+        fundingAddress: state.fundingAddress,
         recentWin: state.recentWin === null
             ? null
             : {
@@ -378,18 +397,14 @@ export class MiningFollowVisualizer {
             artworkCogText: formatCompactCogBalanceText(uiState.balanceCogtoshi),
             artworkSatText: formatCompactSatBalanceText(uiState.balanceSats),
             extraLines: [
-                `✎ Block #${uiState.settledBlockHeight ?? "-----"} Sentences ✎`,
-                "",
+                formatSentenceBoardTitle(uiState.settledBlockHeight),
                 ...Array.from({ length: MINING_SENTENCE_BOARD_SIZE }, (_value, index) => {
                     const entry = uiState.settledBoardEntries[index];
                     return entry === undefined
-                        ? [`${index + 1}.`, ""]
+                        ? `${index + 1}.`
                         : formatSentenceRow(entry);
-                }).flat(),
-                "----------",
-                formatProvisionalTxLinkLine(uiState.provisionalEntry, uiState.provisionalBroadcastTxid),
-                formatRequiredWordsLine(uiState.provisionalRequiredWords),
-                ...formatProvisionalSentenceRow(uiState.provisionalEntry, uiState.provisionalRequiredWords),
+                }),
+                ...formatProvisionalSectionLines(snapshot, uiState),
             ],
         };
         if (this.#artworkStatusLeftText !== null) {

package/dist/wallet/read/context.js

@@ -2,6 +2,8 @@ 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 { deriveManagedBitcoindWalletStatus, resolveManagedBitcoindProbeDecision, } from "../../bitcoind/managed-runtime/bitcoind-policy.js";
+import { deriveManagedIndexerWalletStatus, resolveIndexerDaemonProbeDecision, } from "../../bitcoind/managed-runtime/indexer-policy.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { UNINITIALIZED_WALLET_ROOT_ID } from "../../bitcoind/service-paths.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
@@ -19,7 +21,6 @@ import { createDefaultWalletSecretProvider, createWalletSecretReference, inspect
 import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.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.";
@@ -222,135 +223,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 {
@@ -381,58 +253,6 @@ function deriveNodeHealth(status, bitcoindHealth) {
 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({
@@ -442,13 +262,14 @@ async function attachNodeStatus(options) {
             walletRootId: options.walletRootId,
             startupTimeoutMs: options.startupTimeoutMs,
         });
-        if (probe.compatibility !== "compatible" && probe.compatibility !== "unreachable") {
+        const decision = resolveManagedBitcoindProbeDecision(probe);
+        if (decision.action === "reject") {
             return {
                 handle: null,
                 rpc: null,
                 status: null,
                 observedStatus: probe.status,
-                error: probe.error,
+                error: decision.error,
             };
         }
         const genesis = await loadBundledGenesisParameters();
@@ -539,7 +360,7 @@ export async function openWalletReadContext(options) {
             walletReplicaMessage: verifiedReplica.message ?? null,
         };
     }
-    const bitcoind = deriveBitcoindHealth({
+    const bitcoind = deriveManagedBitcoindWalletStatus({
         status: node.observedStatus,
         nodeStatus: node.status,
         startupError: node.error,
@@ -556,7 +377,11 @@ export async function openWalletReadContext(options) {
             dataDir: options.dataDir,
             walletRootId,
         });
-        if (probe.compatibility === "compatible" || probe.compatibility === "unreachable") {
+        const probeDecision = resolveIndexerDaemonProbeDecision({
+            probe,
+            expectedBinaryVersion: expectedIndexerBinaryVersion,
+        });
+        if (probeDecision.action !== "reject") {
             await probe.client?.close().catch(() => undefined);
             daemonClient = await attachOrStartIndexerDaemon({
                 dataDir: options.dataDir,
@@ -570,7 +395,7 @@ export async function openWalletReadContext(options) {
         else {
             observedDaemonStatus = probe.status;
             indexerSource = probe.status === null ? "none" : "probe";
-            daemonError = probe.error;
+            daemonError = probeDecision.error;
         }
         if (daemonClient !== null) {
             const lease = await readSnapshotWithRetry(daemonClient, walletRootId);
@@ -604,7 +429,7 @@ export async function openWalletReadContext(options) {
             }
         }
     }
-    const indexer = deriveIndexerHealth({
+    const indexer = deriveManagedIndexerWalletStatus({
         daemonStatus,
         observedStatus: observedDaemonStatus,
         snapshot,

package/dist/wallet/reset.d.ts

@@ -38,7 +38,7 @@ export interface WalletResetPreview {
     confirmationPhrase: "permanently reset";
     walletPrompt: null | {
         defaultAction: "retain-mnemonic";
-        acceptedInputs: ["", "skip", "delete wallet"];
+        acceptedInputs: ["", "skip", "clear wallet entropy"];
         entropyRetainingResetAvailable: boolean;
         envelopeSource: "primary" | "backup" | null;
     };