@cogcoin/client 1.1.6 → 1.1.8

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

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
@@ -8,7 +7,6 @@ import { openWalletReadContext } from "../read/index.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import type { WalletSecretProvider } from "../state/provider.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
-import { inspectMiningControlPlane } from "./control.js";
 import { saveStopSnapshot } from "./lifecycle.js";
 import type { MiningRpcClient } from "./engine-types.js";
 import { loadMiningRuntimeStatus, saveMiningRuntimeStatus } from "./runtime-artifacts.js";
@@ -19,9 +17,8 @@ type AttachService = typeof attachOrStartManagedBitcoindService;
 type RpcFactory = (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
 type RequestMiningPreemption = typeof requestMiningGenerationPreemption;
 type SaveStopSnapshot = typeof saveStopSnapshot;
-type SpawnWorkerProcess = typeof spawn;
 type ProcessKill = typeof process.kill;
-type InspectMiningControlPlane = typeof inspectMiningControlPlane;
+type ForceExit = (code: number) => never | void;
 interface MiningLoopRunnerOptions {
     dataDir: string;
     databasePath: string;
@@ -51,9 +48,7 @@ export interface MiningSupervisorRuntimeContext {
 interface MiningSupervisorDependencies {
     requestMiningPreemption: RequestMiningPreemption;
     saveStopSnapshot: SaveStopSnapshot;
-    spawnWorkerProcess: SpawnWorkerProcess;
     runMiningLoop: RunMiningLoop;
-    inspectMiningControlPlane: InspectMiningControlPlane;
     loadRuntimeStatus: typeof loadMiningRuntimeStatus;
     saveRuntimeStatus: typeof saveMiningRuntimeStatus;
     acquireLock: typeof acquireFileLock;
@@ -64,12 +59,7 @@ interface MiningSupervisorDependencies {
     nowUnixMs: () => number;
     processKill: ProcessKill;
     processPid: number;
-    processExecPath: string;
-    resolveWorkerMainPath: () => string;
-}
-export interface MiningSupervisorStartResult {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
+    forceExit: ForceExit;
 }
 export interface MiningSupervisorTakeoverResult {
     controlLockCleared: boolean;
@@ -86,7 +76,6 @@ export declare function takeOverMiningRuntime(options: {
     shutdownGraceMs?: number;
     deps?: Partial<MiningSupervisorDependencies>;
 }): Promise<MiningSupervisorTakeoverResult>;
-export declare function waitForBackgroundHealthy(paths: WalletRuntimePaths, depsOverrides?: Partial<MiningSupervisorDependencies>): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: {
     dataDir: string;
     databasePath: string;
@@ -108,27 +97,4 @@ export declare function runForegroundMining(options: {
     runtime: MiningSupervisorRuntimeContext;
     deps?: Partial<MiningSupervisorDependencies>;
 }): Promise<void>;
-export declare function startBackgroundMining(options: {
-    dataDir: string;
-    databasePath: string;
-    shutdownGraceMs?: number;
-    waitForBackgroundHealthy?: (paths: WalletRuntimePaths) => Promise<MiningRuntimeStatusV1 | null>;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<MiningSupervisorStartResult>;
-export declare function stopBackgroundMining(options: {
-    dataDir: string;
-    databasePath: string;
-    shutdownGraceMs?: number;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<MiningRuntimeStatusV1 | null>;
-export declare function runBackgroundMiningWorker(options: {
-    dataDir: string;
-    databasePath: string;
-    runId: string;
-    fetchImpl?: typeof fetch;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<void>;
 export {};

package/dist/wallet/mining/supervisor.js

@@ -1,21 +1,22 @@
-import { randomBytes } from "node:crypto";
-import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { FileLockBusyError, acquireFileLock, clearOrphanedFileLock, readLockMetadata, } from "../fs/lock.js";
 import { openWalletReadContext } from "../read/index.js";
+import { destroyAllClientPasswordSessionsResolved } from "../state/client-password/session.js";
 import { readMiningGenerationActivity, requestMiningGenerationPreemption, } from "./coordination.js";
-import { inspectMiningControlPlane } from "./control.js";
-import { MINING_SHUTDOWN_GRACE_MS, MINING_WORKER_API_VERSION, } from "./constants.js";
+import { MINING_SHUTDOWN_GRACE_MS, } from "./constants.js";
 import { saveStopSnapshot } from "./lifecycle.js";
 import { loadMiningRuntimeStatus, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
+import { createMiningStopRequestedError } from "./stop.js";
 import { MiningFollowVisualizer } from "./visualizer.js";
-const BACKGROUND_START_TIMEOUT_MS = 15_000;
 function sleep(ms, signal) {
     return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
         const timer = setTimeout(resolve, ms);
         signal?.addEventListener("abort", () => {
             clearTimeout(timer);
@@ -23,15 +24,23 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
+function createOneShotClientPasswordSessionDestroyer() {
+    let destroyed = false;
+    return () => {
+        if (destroyed) {
+            return;
+        }
+        destroyed = true;
+        destroyAllClientPasswordSessionsResolved();
+    };
+}
 function resolveSupervisorDependencies(overrides = {}) {
     return {
         requestMiningPreemption: overrides.requestMiningPreemption ?? requestMiningGenerationPreemption,
         saveStopSnapshot: overrides.saveStopSnapshot ?? saveStopSnapshot,
-        spawnWorkerProcess: overrides.spawnWorkerProcess ?? spawn,
         runMiningLoop: overrides.runMiningLoop ?? (() => {
             throw new Error("mining_supervisor_run_loop_missing");
         }),
-        inspectMiningControlPlane: overrides.inspectMiningControlPlane ?? inspectMiningControlPlane,
         loadRuntimeStatus: overrides.loadRuntimeStatus ?? loadMiningRuntimeStatus,
         saveRuntimeStatus: overrides.saveRuntimeStatus ?? saveMiningRuntimeStatus,
         acquireLock: overrides.acquireLock ?? acquireFileLock,
@@ -42,11 +51,17 @@ function resolveSupervisorDependencies(overrides = {}) {
         nowUnixMs: overrides.nowUnixMs ?? Date.now,
         processKill: overrides.processKill ?? process.kill.bind(process),
         processPid: overrides.processPid ?? process.pid,
-        processExecPath: overrides.processExecPath ?? process.execPath,
-        resolveWorkerMainPath: overrides.resolveWorkerMainPath
-            ?? (() => fileURLToPath(new URL("./worker-main.js", import.meta.url))),
+        forceExit: overrides.forceExit ?? ((code) => {
+            process.exit(code);
+        }),
     };
 }
+class ForegroundMiningShutdownTimeoutError extends Error {
+    constructor() {
+        super("mining_foreground_shutdown_timeout");
+        this.name = "ForegroundMiningShutdownTimeoutError";
+    }
+}
 async function isProcessAlive(pid, deps) {
     if (pid === null) {
         return false;
@@ -294,265 +309,143 @@ async function acquireMiningStartControlLock(options) {
         }
     }
 }
-export async function waitForBackgroundHealthy(paths, depsOverrides = {}) {
-    const deps = resolveSupervisorDependencies(depsOverrides);
-    const deadline = deps.nowUnixMs() + BACKGROUND_START_TIMEOUT_MS;
-    while (deps.nowUnixMs() < deadline) {
-        const snapshot = await deps.loadRuntimeStatus(paths.miningStatusPath).catch(() => null);
-        if (snapshot !== null
-            && snapshot.runMode === "background"
-            && snapshot.backgroundWorkerHealth === "healthy") {
-            return snapshot;
-        }
-        await deps.sleep(250);
-    }
-    return deps.loadRuntimeStatus(paths.miningStatusPath).catch(() => null);
-}
 export async function runForegroundMining(options) {
     const deps = resolveSupervisorDependencies(options.deps);
+    const shutdownGraceMs = options.shutdownGraceMs ?? MINING_SHUTDOWN_GRACE_MS;
+    const usesExternalSignal = options.signal !== undefined;
     let visualizer = options.visualizer ?? null;
     const ownsVisualizer = visualizer === null;
+    const destroyClientPasswordSessions = createOneShotClientPasswordSessionDestroyer();
     const controlLock = await acquireMiningStartControlLock({
         paths: options.runtime.paths,
         purpose: "mine-foreground",
         takeoverReason: "mine-foreground-replace",
-        shutdownGraceMs: options.shutdownGraceMs,
+        shutdownGraceMs,
         deps,
     });
     const abortController = new AbortController();
+    let stopRequested = false;
+    let shutdownDeadlineTimer = null;
+    let rejectShutdownDeadline = null;
+    let forceExitIssued = false;
+    const shutdownDeadline = new Promise((_, reject) => {
+        rejectShutdownDeadline = reject;
+    });
+    const requestStop = () => {
+        if (stopRequested) {
+            return;
+        }
+        stopRequested = true;
+        if (!abortController.signal.aborted) {
+            abortController.abort(createMiningStopRequestedError());
+        }
+        shutdownDeadlineTimer = setTimeout(() => {
+            rejectShutdownDeadline?.(new ForegroundMiningShutdownTimeoutError());
+        }, shutdownGraceMs);
+        shutdownDeadlineTimer.unref?.();
+    };
     const abortListener = () => {
-        abortController.abort();
+        requestStop();
     };
-    const handleSigint = () => abortController.abort();
-    const handleSigterm = () => abortController.abort();
-    try {
-        await takeOverMiningRuntime({
-            paths: options.runtime.paths,
-            reason: "mine-foreground-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
-        if (visualizer === null) {
-            visualizer = new MiningFollowVisualizer({
-                clientVersion: options.clientVersion,
-                updateAvailable: options.updateAvailable,
-                progressOutput: options.progressOutput ?? "auto",
-                stream: options.stderr,
+    const handleSigint = () => {
+        requestStop();
+    };
+    const handleSigterm = () => {
+        requestStop();
+    };
+    const issueForcedExit = (code) => {
+        if (forceExitIssued) {
+            return;
+        }
+        forceExitIssued = true;
+        visualizer?.close();
+        destroyClientPasswordSessions();
+        return deps.forceExit(code);
+    };
+    const gracefulRun = async () => {
+        try {
+            await takeOverMiningRuntime({
+                paths: options.runtime.paths,
+                reason: "mine-foreground-replace",
+                shutdownGraceMs,
+                deps,
+            });
+            if (visualizer === null) {
+                visualizer = new MiningFollowVisualizer({
+                    clientVersion: options.clientVersion,
+                    updateAvailable: options.updateAvailable,
+                    progressOutput: options.progressOutput ?? "auto",
+                    stream: options.stderr,
+                });
+            }
+            await deps.runMiningLoop({
+                dataDir: options.dataDir,
+                databasePath: options.databasePath,
+                provider: options.runtime.provider,
+                paths: options.runtime.paths,
+                runMode: "foreground",
+                backgroundWorkerPid: null,
+                backgroundWorkerRunId: null,
+                signal: abortController.signal,
+                fetchImpl: options.fetchImpl,
+                openReadContext: options.runtime.openReadContext,
+                attachService: options.runtime.attachService,
+                rpcFactory: options.runtime.rpcFactory,
+                stdout: options.stdout,
+                visualizer,
+            });
+            await deps.saveStopSnapshot({
+                dataDir: options.dataDir,
+                databasePath: options.databasePath,
+                provider: options.runtime.provider,
+                paths: options.runtime.paths,
+                runMode: "foreground",
+                backgroundWorkerPid: null,
+                backgroundWorkerRunId: null,
+                note: "Foreground mining stopped cleanly.",
             });
         }
-        options.signal?.addEventListener("abort", abortListener, { once: true });
-        process.on("SIGINT", handleSigint);
-        process.on("SIGTERM", handleSigterm);
-        await deps.runMiningLoop({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "foreground",
-            backgroundWorkerPid: null,
-            backgroundWorkerRunId: null,
-            signal: abortController.signal,
-            fetchImpl: options.fetchImpl,
-            openReadContext: options.runtime.openReadContext,
-            attachService: options.runtime.attachService,
-            rpcFactory: options.runtime.rpcFactory,
-            stdout: options.stdout,
-            visualizer,
-        });
-        await deps.saveStopSnapshot({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "foreground",
-            backgroundWorkerPid: null,
-            backgroundWorkerRunId: null,
-            note: "Foreground mining stopped cleanly.",
-        });
-    }
-    finally {
-        options.signal?.removeEventListener("abort", abortListener);
-        process.off("SIGINT", handleSigint);
-        process.off("SIGTERM", handleSigterm);
-        if (ownsVisualizer) {
-            visualizer?.close();
+        finally {
+            if (ownsVisualizer) {
+                visualizer?.close();
+            }
+            await controlLock.release();
+            destroyClientPasswordSessions();
         }
-        await controlLock.release();
-    }
-}
-export async function startBackgroundMining(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const waitForHealthy = options.waitForBackgroundHealthy
-        ?? (async (paths) => await waitForBackgroundHealthy(paths, deps));
-    let controlLock;
+    };
+    const gracefulRunPromise = gracefulRun();
     try {
-        controlLock = await acquireMiningStartControlLock({
-            paths: options.runtime.paths,
-            purpose: "mine-start",
-            takeoverReason: "mine-start-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
+        if (options.signal?.aborted) {
+            requestStop();
+        }
+        else {
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+        }
+        if (!usesExternalSignal) {
+            process.on("SIGINT", handleSigint);
+            process.on("SIGTERM", handleSigterm);
+        }
+        await Promise.race([
+            gracefulRunPromise,
+            shutdownDeadline,
+        ]);
     }
     catch (error) {
-        if (error instanceof FileLockBusyError && error.existingMetadata?.processId === deps.processPid) {
-            return {
-                started: false,
-                snapshot: await deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null),
-            };
+        if (error instanceof ForegroundMiningShutdownTimeoutError) {
+            gracefulRunPromise.catch(() => undefined);
+            issueForcedExit(130);
+            return;
         }
         throw error;
     }
-    try {
-        await takeOverMiningRuntime({
-            paths: options.runtime.paths,
-            reason: "mine-start-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
-        const runId = randomBytes(16).toString("hex");
-        const child = deps.spawnWorkerProcess(deps.processExecPath, [
-            deps.resolveWorkerMainPath(),
-            `--data-dir=${options.dataDir}`,
-            `--database-path=${options.databasePath}`,
-            `--run-id=${runId}`,
-        ], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-        const snapshot = await waitForHealthy(options.runtime.paths);
-        return {
-            started: true,
-            snapshot,
-        };
-    }
     finally {
-        await controlLock.release();
-    }
-}
-export async function stopBackgroundMining(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const shutdownGraceMs = options.shutdownGraceMs ?? MINING_SHUTDOWN_GRACE_MS;
-    const controlLock = await deps.acquireLock(options.runtime.paths.miningControlLockPath, {
-        purpose: "mine-stop",
-    });
-    try {
-        const snapshot = await deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null);
-        if (snapshot === null || snapshot.runMode !== "background" || snapshot.backgroundWorkerPid === null) {
-            return snapshot;
-        }
-        const preemption = await deps.requestMiningPreemption({
-            paths: options.runtime.paths,
-            reason: "mine-stop",
-            timeoutMs: Math.min(shutdownGraceMs, 15_000),
-        }).catch(() => null);
-        try {
-            try {
-                deps.processKill(snapshot.backgroundWorkerPid, "SIGTERM");
-            }
-            catch (error) {
-                if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
-                    throw error;
-                }
-            }
-            const deadline = deps.nowUnixMs() + shutdownGraceMs;
-            while (deps.nowUnixMs() < deadline) {
-                if (!await isProcessAlive(snapshot.backgroundWorkerPid, deps)) {
-                    break;
-                }
-                await deps.sleep(250);
-            }
-            if (await isProcessAlive(snapshot.backgroundWorkerPid, deps)) {
-                try {
-                    deps.processKill(snapshot.backgroundWorkerPid, "SIGKILL");
-                }
-                catch {
-                    // ignore
-                }
-            }
+        if (shutdownDeadlineTimer !== null) {
+            clearTimeout(shutdownDeadlineTimer);
         }
-        finally {
-            await preemption?.release().catch(() => undefined);
+        options.signal?.removeEventListener("abort", abortListener);
+        if (!usesExternalSignal) {
+            process.off("SIGINT", handleSigint);
+            process.off("SIGTERM", handleSigterm);
         }
-        await deps.saveStopSnapshot({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "background",
-            backgroundWorkerPid: snapshot.backgroundWorkerPid,
-            backgroundWorkerRunId: snapshot.backgroundWorkerRunId,
-            note: snapshot.livePublishInMempool
-                ? "Background mining stopped. The last mining transaction may still confirm from mempool."
-                : "Background mining stopped.",
-        });
-        return deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null);
-    }
-    finally {
-        await controlLock.release();
-    }
-}
-export async function runBackgroundMiningWorker(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const abortController = new AbortController();
-    process.on("SIGINT", () => abortController.abort());
-    process.on("SIGTERM", () => abortController.abort());
-    const initialContext = await options.runtime.openReadContext({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        secretProvider: options.runtime.provider,
-        paths: options.runtime.paths,
-    });
-    try {
-        const initialView = await deps.inspectMiningControlPlane({
-            provider: options.runtime.provider,
-            localState: initialContext.localState,
-            bitcoind: initialContext.bitcoind,
-            nodeStatus: initialContext.nodeStatus,
-            nodeHealth: initialContext.nodeHealth,
-            indexer: initialContext.indexer,
-            paths: options.runtime.paths,
-        });
-        await deps.saveRuntimeStatus(options.runtime.paths.miningStatusPath, {
-            ...initialView.runtime,
-            walletRootId: initialContext.localState.walletRootId,
-            workerApiVersion: MINING_WORKER_API_VERSION,
-            workerBinaryVersion: process.version,
-            workerBuildId: options.runId,
-            runMode: "background",
-            backgroundWorkerPid: deps.processPid,
-            backgroundWorkerRunId: options.runId,
-            backgroundWorkerHeartbeatAtUnixMs: deps.nowUnixMs(),
-            currentPhase: "idle",
-            updatedAtUnixMs: deps.nowUnixMs(),
-        });
-    }
-    finally {
-        await initialContext.close();
     }
-    await deps.runMiningLoop({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        provider: options.runtime.provider,
-        paths: options.runtime.paths,
-        runMode: "background",
-        backgroundWorkerPid: deps.processPid,
-        backgroundWorkerRunId: options.runId,
-        signal: abortController.signal,
-        fetchImpl: options.fetchImpl,
-        openReadContext: options.runtime.openReadContext,
-        attachService: options.runtime.attachService,
-        rpcFactory: options.runtime.rpcFactory,
-    });
-    await deps.saveStopSnapshot({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        provider: options.runtime.provider,
-        paths: options.runtime.paths,
-        runMode: "background",
-        backgroundWorkerPid: deps.processPid,
-        backgroundWorkerRunId: options.runId,
-        note: "Background mining worker stopped cleanly.",
-    });
 }

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

@@ -4,6 +4,12 @@ import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-
 import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
 import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
+function cloneSettledBoardEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        requiredWords: [...entry.requiredWords],
+    }));
+}
 function resolveSettledWinnerRequiredWords(options) {
     const storedWords = resolveBip39WordsFromIndices(options.bip39WordIndices);
     if (storedWords.length > 0) {
@@ -20,6 +26,46 @@ function resolveSettledWinnerRequiredWords(options) {
 function fallbackSettledWinnerDomainName(domainId) {
     return `domain-${domainId}`;
 }
+function resolveSettledBoardEntriesForHeight(options) {
+    if (options.snapshotState === null || options.snapshotState === undefined) {
+        return null;
+    }
+    const winners = getBlockWinners(options.snapshotState, options.blockHeight);
+    if (winners === null) {
+        return null;
+    }
+    const snapshotState = options.snapshotState;
+    return winners
+        .slice()
+        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
+        .slice(0, 5)
+        .map((winner) => ({
+        rank: winner.rank,
+        domainName: lookupDomainById(snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
+        sentence: winner.sentenceText ?? "[unavailable]",
+        requiredWords: resolveSettledWinnerRequiredWords({
+            domainId: winner.domainId,
+            bip39WordIndices: winner.bip39WordIndices,
+            snapshotTipPreviousHashHex: options.blockPreviousHashHex,
+        }),
+    }));
+}
+function resolveLatestPriorNonEmptySettledBoard(options) {
+    for (let blockHeight = options.snapshotTipHeight - 1; blockHeight >= 0; blockHeight -= 1) {
+        const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+            snapshotState: options.snapshotState,
+            blockHeight,
+            blockPreviousHashHex: null,
+        });
+        if (settledBoardEntries !== null && settledBoardEntries.length > 0) {
+            return {
+                settledBlockHeight: blockHeight,
+                settledBoardEntries,
+            };
+        }
+    }
+    return null;
+}
 function resolveCurrentMinedBlockBoard(options) {
     const settledBlockHeight = options.snapshotTipHeight ?? null;
     if (settledBlockHeight === null) {
@@ -34,23 +80,37 @@ function resolveCurrentMinedBlockBoard(options) {
             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,
-        }),
-    }));
+    const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+        snapshotState: options.snapshotState,
+        blockHeight: settledBlockHeight,
+        blockPreviousHashHex: options.snapshotTipPreviousHashHex,
+    });
+    if (settledBoardEntries !== null) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries,
+        };
+    }
+    const currentDisplayedBlockHeight = options.currentDisplayedBoard?.settledBlockHeight ?? null;
+    const currentDisplayedEntries = options.currentDisplayedBoard?.settledBoardEntries ?? [];
+    if (currentDisplayedBlockHeight !== null
+        && currentDisplayedBlockHeight <= settledBlockHeight
+        && currentDisplayedEntries.length > 0) {
+        return {
+            settledBlockHeight: currentDisplayedBlockHeight,
+            settledBoardEntries: cloneSettledBoardEntries(currentDisplayedEntries),
+        };
+    }
+    const latestPriorNonEmptyBoard = resolveLatestPriorNonEmptySettledBoard({
+        snapshotState: options.snapshotState,
+        snapshotTipHeight: settledBlockHeight,
+    });
+    if (latestPriorNonEmptyBoard !== null) {
+        return latestPriorNonEmptyBoard;
+    }
     return {
         settledBlockHeight,
-        settledBoardEntries,
+        settledBoardEntries: [],
     };
 }
 export function resolveSettledBoard(options) {
@@ -66,6 +126,10 @@ function syncMiningUiSettledBoard(loopState, snapshotState, snapshotTipHeight, s
         snapshotState,
         snapshotTipHeight,
         snapshotTipPreviousHashHex,
+        currentDisplayedBoard: {
+            settledBlockHeight: loopState.ui.settledBlockHeight,
+            settledBoardEntries: loopState.ui.settledBoardEntries,
+        },
     });
     loopState.ui.settledBlockHeight = settledBoard.settledBlockHeight;
     loopState.ui.settledBoardEntries = settledBoard.settledBoardEntries;

package/dist/wallet/read/context.d.ts

@@ -1,6 +1,6 @@
 import { readSnapshotWithRetry } from "../../bitcoind/indexer-daemon.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletReadContext, WalletServiceHealth } from "./types.js";
+import type { WalletLocalStateStatus, WalletReadContext } from "./types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 declare function inspectWalletLocalState(options?: {
     dataDir?: string;
@@ -9,10 +9,6 @@ declare function inspectWalletLocalState(options?: {
     paths?: WalletRuntimePaths;
     walletControlLockHeld?: boolean;
 }): Promise<WalletLocalStateStatus>;
-export declare function deriveNodeHealthForTesting(status: WalletNodeStatus | null, bitcoindHealth: WalletBitcoindStatus["health"]): {
-    health: WalletServiceHealth;
-    message: string | null;
-};
 export declare function openWalletReadContext(options: {
     dataDir: string;
     databasePath: string;