@cogcoin/client 0.5.15 → 1.0.1

package/dist/wallet/mining/visualizer.js

@@ -1,7 +1,87 @@
 import { createBootstrapProgress } from "../../bitcoind/progress/formatting.js";
-import { createFollowSceneState, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.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";
+const MINING_ARTWORK_COG_WIDTH = 22;
+const MINING_SENTENCE_BOARD_SIZE = 5;
+function formatCogAmountWithDecimals(value, { maxFractionDigits, minFractionDigits, }) {
+    const sign = value < 0n ? "-" : "";
+    const absolute = value < 0n ? -value : value;
+    const whole = absolute / 100000000n;
+    const fraction = absolute % 100000000n;
+    const paddedFraction = fraction.toString().padStart(8, "0");
+    const clampedMax = Math.max(0, Math.min(8, maxFractionDigits));
+    const clampedMin = Math.max(0, Math.min(clampedMax, minFractionDigits));
+    let fractionText = paddedFraction.slice(0, clampedMax);
+    while (fractionText.length > clampedMin && fractionText.endsWith("0")) {
+        fractionText = fractionText.slice(0, -1);
+    }
+    if (fractionText.length === 0 && clampedMin > 0) {
+        fractionText = "".padEnd(clampedMin, "0");
+    }
+    return fractionText.length > 0
+        ? `${sign}${whole.toString()}.${fractionText}`
+        : `${sign}${whole.toString()}`;
+}
+function formatCompactCogBalanceText(balanceCogtoshi) {
+    if (balanceCogtoshi === null) {
+        return null;
+    }
+    for (let digits = 4; digits >= 1; digits -= 1) {
+        const cogSegment = `${formatCogAmountWithDecimals(balanceCogtoshi, {
+            maxFractionDigits: digits,
+            minFractionDigits: 1,
+        })} COG`;
+        if (cogSegment.length <= MINING_ARTWORK_COG_WIDTH) {
+            return cogSegment;
+        }
+    }
+    return `${formatCogAmountWithDecimals(balanceCogtoshi, {
+        maxFractionDigits: 1,
+        minFractionDigits: 1,
+    })} COG`;
+}
+function formatCompactSatBalanceText(balanceSats) {
+    return balanceSats === null ? null : `${balanceSats.toString()} SAT`;
+}
+function formatRewardCogAmount(value) {
+    return `${formatCogAmountWithDecimals(value, {
+        maxFractionDigits: 8,
+        minFractionDigits: 1,
+    })} COG`;
+}
+function formatSentenceRow(rank, domainName, sentence) {
+    return `${rank}. @${domainName}: ${sentence}`;
+}
+function formatRequiredWordsLine(words) {
+    if (words.length === 0) {
+        return "";
+    }
+    return `Required words: ${words.map((word) => word.toUpperCase()).join(", ")}`;
+}
+function formatProvisionalSentenceRow(entry) {
+    if (entry.domainName === null || entry.sentence === null) {
+        return "";
+    }
+    return `@${entry.domainName}: ${entry.sentence}`;
+}
+export function createEmptyMiningFollowVisualizerState() {
+    return {
+        balanceCogtoshi: null,
+        balanceSats: null,
+        visibleBlockTimesByHeight: {},
+        settledBlockHeight: null,
+        settledBoardEntries: [],
+        provisionalRequiredWords: [],
+        provisionalEntry: {
+            domainName: null,
+            sentence: null,
+        },
+        latestSentence: null,
+        latestTxid: null,
+        recentWin: null,
+    };
+}
 const VISUALIZER_PROGRESS_SNAPSHOT = {
     url: "",
     filename: "mining-follow-visualizer",
@@ -9,14 +89,15 @@ const VISUALIZER_PROGRESS_SNAPSHOT = {
     sha256: "",
     sizeBytes: 1,
 };
-export function describeMiningVisualizerStatus(snapshot) {
+export function describeMiningVisualizerStatus(snapshot, ui = createEmptyMiningFollowVisualizerState()) {
+    if (ui.recentWin !== null) {
+        return `You got #${ui.recentWin.rank} and mined ${formatRewardCogAmount(ui.recentWin.rewardCogtoshi)} in block #${ui.recentWin.blockHeight}`;
+    }
     switch (snapshot.currentPhase) {
         case "resuming":
             return "Resuming after suspend";
         case "waiting-provider":
-            return snapshot.providerState === "hook-error"
-                ? "Waiting for hook"
-                : "Waiting for provider";
+            return "Waiting for provider";
         case "waiting-indexer":
             return snapshot.indexerDaemonState === "reorging"
                 ? "Indexer replaying reorg"
@@ -54,7 +135,7 @@ export function describeMiningVisualizerStatus(snapshot) {
     if (snapshot.currentPublishDecision === "indeterminate-mempool-gate") {
         return "Mempool gate indeterminate";
     }
-    if (snapshot.liveMiningFamilyInMempool) {
+    if (snapshot.livePublishInMempool) {
         return "Waiting for next block";
     }
     return "Waiting for next block";
@@ -78,7 +159,7 @@ export function describeMiningVisualizerProgress(snapshot) {
             return "Scoring mining candidates for the current tip.";
         case "publishing":
             return snapshot.currentPublishDecision === "fee-bump"
-                ? "Publishing a fee bump for the live mining family."
+                ? "Publishing a fee bump for the live mining transaction."
                 : snapshot.currentPublishDecision === "replacing"
                     || snapshot.currentPublishDecision === "replaced"
                     ? "Replacing the live mining transaction for the current tip."
@@ -95,7 +176,9 @@ export class MiningFollowVisualizer {
     #renderThrottle;
     #progress = createBootstrapProgress("follow_tip", VISUALIZER_PROGRESS_SNAPSHOT);
     #scene = createFollowSceneState();
+    #ticker = null;
     #latestSnapshot = null;
+    #latestUiState = createEmptyMiningFollowVisualizerState();
     constructor(options = {}) {
         const stream = options.stream ?? process.stderr;
         const progressOutput = options.progressOutput ?? "auto";
@@ -115,23 +198,51 @@ export class MiningFollowVisualizer {
             },
             throttled: renderPolicy.linuxHeadlessThrottle,
         });
+        if (this.#renderer !== null) {
+            this.#ticker = this.#clock.setInterval(() => {
+                this.#advanceAndRender();
+            }, renderPolicy.repaintIntervalMs);
+        }
     }
-    update(snapshot) {
+    update(snapshot, uiState) {
         if (this.#renderer === null) {
             return;
         }
         this.#latestSnapshot = snapshot;
+        if (uiState !== undefined) {
+            this.#latestUiState = uiState;
+        }
+        replaceFollowBlockTimes(this.#scene, this.#latestUiState.visibleBlockTimesByHeight);
+        const indexedHeight = snapshot.indexerTipHeight ?? snapshot.coreBestHeight ?? null;
+        const nodeHeight = snapshot.coreBestHeight ?? indexedHeight;
+        syncFollowSceneState(this.#scene, {
+            indexedHeight,
+            nodeHeight,
+            liveActivated: true,
+        });
         this.#renderThrottle.request();
     }
     close() {
+        if (this.#ticker !== null) {
+            this.#clock.clearInterval(this.#ticker);
+            this.#ticker = null;
+        }
         this.#renderThrottle.flush();
         this.#renderer?.close();
     }
+    #advanceAndRender() {
+        if (this.#renderer === null || this.#latestSnapshot === null) {
+            return;
+        }
+        advanceFollowSceneState(this.#scene, this.#clock.now());
+        this.#renderThrottle.request();
+    }
     #renderLatestSnapshot() {
         if (this.#renderer === null || this.#latestSnapshot === null) {
             return;
         }
         const snapshot = this.#latestSnapshot;
+        const uiState = this.#latestUiState;
         const indexedHeight = snapshot.indexerTipHeight ?? snapshot.coreBestHeight ?? null;
         const nodeHeight = snapshot.coreBestHeight ?? indexedHeight;
         this.#progress.phase = "follow_tip";
@@ -141,11 +252,22 @@ export class MiningFollowVisualizer {
         this.#progress.targetHeight = nodeHeight;
         this.#progress.etaSeconds = null;
         this.#progress.lastError = snapshot.lastError;
-        syncFollowSceneState(this.#scene, {
-            indexedHeight,
-            nodeHeight,
-            liveActivated: true,
+        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot, uiState), {
+            artworkCogText: formatCompactCogBalanceText(uiState.balanceCogtoshi),
+            artworkSatText: formatCompactSatBalanceText(uiState.balanceSats),
+            extraLines: [
+                `✎ Block #${uiState.settledBlockHeight ?? "-----"} Sentences ✎`,
+                "",
+                ...Array.from({ length: MINING_SENTENCE_BOARD_SIZE }, (_value, index) => {
+                    const entry = uiState.settledBoardEntries[index];
+                    return entry === undefined
+                        ? `${index + 1}.`
+                        : formatSentenceRow(entry.rank, entry.domainName, entry.sentence);
+                }),
+                "----------",
+                formatRequiredWordsLine(uiState.provisionalRequiredWords),
+                formatProvisionalSentenceRow(uiState.provisionalEntry),
+            ],
         });
-        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot));
     }
 }

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

@@ -4,7 +4,6 @@ import type { WalletLocalStateStatus, WalletReadContext } from "./types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 declare function inspectWalletLocalState(options?: {
     dataDir?: string;
-    passphrase?: Uint8Array | string;
     secretProvider?: WalletSecretProvider;
     now?: number;
     paths?: WalletRuntimePaths;
@@ -13,7 +12,6 @@ declare function inspectWalletLocalState(options?: {
 export declare function openWalletReadContext(options: {
     dataDir: string;
     databasePath: string;
-    walletStatePassphrase?: Uint8Array | string;
     secretProvider?: WalletSecretProvider;
     walletControlLockHeld?: boolean;
     startupTimeoutMs?: number;

package/dist/wallet/read/context.js

@@ -6,19 +6,28 @@ import { UNINITIALIZED_WALLET_ROOT_ID } from "../../bitcoind/service-paths.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
 import { resolveCogcoinProcessingStartHeight } from "../../bitcoind/processing-start-height.js";
 import {} from "../../bitcoind/types.js";
-import { loadOrAutoUnlockWalletState, verifyManagedCoreWalletReplica, } from "../lifecycle.js";
+import { verifyManagedCoreWalletReplica, } from "../lifecycle.js";
 import { normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
 import { persistNormalizedWalletDescriptorStateIfNeeded } from "../descriptor-normalization.js";
 import { inspectMiningControlPlane } from "../mining/index.js";
 import { normalizeMiningStateRecord } from "../mining/state.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../root-resolution.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
-import { loadWalletExplicitLock } from "../state/explicit-lock.js";
-import { loadWalletState } from "../state/storage.js";
-import { createDefaultWalletSecretProvider, createWalletSecretReference, } from "../state/provider.js";
+import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, } from "../state/storage.js";
+import { createDefaultWalletSecretProvider, createWalletSecretReference, inspectClientPasswordSetupReadiness, } from "../state/provider.js";
+import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.js";
 import { createWalletReadModel } from "./project.js";
 const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
 const STALE_HEARTBEAT_THRESHOLD_MS = 15_000;
+function btcAmountToSats(value) {
+    return BigInt(Math.round(value * 100_000_000));
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
 async function pathExists(path) {
     try {
         await access(path, constants.F_OK);
@@ -28,19 +37,26 @@ async function pathExists(path) {
         return false;
     }
 }
-function isLockedWalletAccessError(error) {
+function isWalletAccessError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    return message === "wallet_envelope_missing_secret_provider"
-        || message.startsWith("wallet_secret_missing_")
-        || message.startsWith("wallet_secret_provider_");
+    return message.startsWith("wallet_secret_missing_")
+        || message.startsWith("wallet_secret_provider_")
+        || message.startsWith("wallet_client_password_")
+        || message === "wallet_state_legacy_envelope_unsupported";
 }
-function describeLockedWalletMessage(options) {
-    if (options.explicitlyLocked) {
-        return "Wallet state exists but is explicitly locked until `cogcoin unlock` is run.";
-    }
+function describeWalletAccessMessage(options) {
     const message = options.accessError instanceof Error ? options.accessError.message : String(options.accessError ?? "");
-    if (message === "wallet_envelope_missing_secret_provider") {
-        return "Wallet state exists but requires the local wallet-state passphrase.";
+    if (message === "wallet_state_legacy_envelope_unsupported") {
+        return "Wallet state exists but was created by an older Cogcoin wallet format that this version no longer loads directly.";
+    }
+    if (message === "wallet_client_password_setup_required") {
+        return describeClientPasswordSetupMessage();
+    }
+    if (message === "wallet_client_password_migration_required") {
+        return describeClientPasswordMigrationMessage();
+    }
+    if (message === "wallet_client_password_locked") {
+        return describeClientPasswordLockedMessage();
     }
     if (message.startsWith("wallet_secret_provider_")) {
         return "Wallet state exists but the local secret provider is unavailable.";
@@ -48,9 +64,9 @@ function describeLockedWalletMessage(options) {
     if (message.startsWith("wallet_secret_missing_")) {
         return "Wallet state exists but its local secret-provider material is unavailable.";
     }
-    return options.hasUnlockSessionFile
-        ? "Wallet state exists but the unlock session is expired, invalid, or belongs to a different wallet root."
-        : "Wallet state exists but is currently locked.";
+    return message.length > 0
+        ? message
+        : "Wallet state exists but could not be loaded from the local secret provider.";
 }
 async function normalizeLoadedWalletStateForRead(options) {
     if (options.dataDir === undefined) {
@@ -63,12 +79,10 @@ async function normalizeLoadedWalletStateForRead(options) {
         walletRootId: options.loaded.state.walletRootId,
     });
     try {
-        const access = typeof options.access === "string" || options.access instanceof Uint8Array
-            ? options.access
-            : {
-                provider: options.access.provider,
-                secretReference: createWalletSecretReference(options.loaded.state.walletRootId),
-            };
+        const access = {
+            provider: options.access.provider,
+            secretReference: createWalletSecretReference(options.loaded.state.walletRootId),
+        };
         const normalized = await persistNormalizedWalletDescriptorStateIfNeeded({
             state: options.loaded.state,
             access,
@@ -98,166 +112,109 @@ async function inspectWalletLocalState(options = {}) {
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
     const now = options.now ?? Date.now();
     const provider = options.secretProvider ?? createDefaultWalletSecretProvider();
-    const [hasPrimaryStateFile, hasBackupStateFile, hasUnlockSessionFile] = await Promise.all([
+    const [hasPrimaryStateFile, hasBackupStateFile] = await Promise.all([
         pathExists(paths.walletStatePath),
         pathExists(paths.walletStateBackupPath),
-        pathExists(paths.walletUnlockSessionPath),
     ]);
+    const clientPasswordReadiness = await inspectClientPasswordSetupReadiness(provider).catch(() => "ready");
     if (!hasPrimaryStateFile && !hasBackupStateFile) {
         return {
             availability: "uninitialized",
+            clientPasswordReadiness,
+            unlockRequired: false,
             walletRootId: null,
             state: null,
             source: null,
-            unlockUntilUnixMs: null,
             hasPrimaryStateFile,
             hasBackupStateFile,
-            hasUnlockSessionFile,
             message: "Wallet state has not been initialized yet.",
         };
     }
-    if (options.passphrase === undefined) {
-        try {
-            const unlocked = await loadOrAutoUnlockWalletState({
-                provider,
-                nowUnixMs: now,
-                paths,
-                dataDir: options.dataDir,
-                controlLockHeld: options.walletControlLockHeld,
-            });
-            if (unlocked === null) {
-                const explicitLock = await loadWalletExplicitLock(paths.walletExplicitLockPath);
-                const hasUnlockSessionFileNow = await pathExists(paths.walletUnlockSessionPath);
-                try {
-                    const loaded = await loadWalletState({
-                        primaryPath: paths.walletStatePath,
-                        backupPath: paths.walletStateBackupPath,
-                    }, {
-                        provider,
-                    });
-                    await normalizeLoadedWalletStateForRead({
-                        loaded,
-                        access: { provider },
-                        dataDir: options.dataDir,
-                        now,
-                        paths,
-                    });
-                    return {
-                        availability: "locked",
-                        walletRootId: loaded.state.walletRootId,
-                        state: null,
-                        source: loaded.source,
-                        unlockUntilUnixMs: null,
-                        hasPrimaryStateFile,
-                        hasBackupStateFile,
-                        hasUnlockSessionFile: hasUnlockSessionFileNow,
-                        message: describeLockedWalletMessage({
-                            explicitlyLocked: explicitLock?.walletRootId === loaded.state.walletRootId,
-                            hasUnlockSessionFile: hasUnlockSessionFileNow,
-                        }),
-                    };
-                }
-                catch (error) {
-                    const resolvedRoot = await resolveWalletRootIdFromLocalArtifacts({
-                        paths,
-                        provider,
-                    }).catch(() => null);
-                    if (isLockedWalletAccessError(error)) {
-                        return {
-                            availability: "locked",
-                            walletRootId: resolvedRoot?.walletRootId ?? null,
-                            state: null,
-                            source: null,
-                            unlockUntilUnixMs: null,
-                            hasPrimaryStateFile,
-                            hasBackupStateFile,
-                            hasUnlockSessionFile: hasUnlockSessionFileNow,
-                            message: describeLockedWalletMessage({
-                                accessError: error,
-                                explicitlyLocked: false,
-                                hasUnlockSessionFile: hasUnlockSessionFileNow,
-                            }),
-                        };
-                    }
-                    return {
-                        availability: "local-state-corrupt",
-                        walletRootId: resolvedRoot?.walletRootId ?? null,
-                        state: null,
-                        source: null,
-                        unlockUntilUnixMs: null,
-                        hasPrimaryStateFile,
-                        hasBackupStateFile,
-                        hasUnlockSessionFile: hasUnlockSessionFileNow,
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            }
-            return {
-                availability: "ready",
-                walletRootId: unlocked.state.walletRootId,
-                state: normalizeWalletStateRecord({
-                    ...unlocked.state,
-                    miningState: normalizeMiningStateRecord(unlocked.state.miningState),
-                }),
-                source: unlocked.source,
-                unlockUntilUnixMs: unlocked.session.unlockUntilUnixMs,
-                hasPrimaryStateFile,
-                hasBackupStateFile,
-                hasUnlockSessionFile: true,
-                message: null,
-            };
-        }
-        catch (error) {
+    if (clientPasswordReadiness !== "ready") {
+        const rawEnvelope = await loadRawWalletStateEnvelope({
+            primaryPath: paths.walletStatePath,
+            backupPath: paths.walletStateBackupPath,
+        }).catch(() => null);
+        if (rawEnvelope?.envelope.secretProvider == null) {
             return {
                 availability: "local-state-corrupt",
-                walletRootId: null,
+                clientPasswordReadiness: "ready",
+                unlockRequired: false,
+                walletRootId: extractWalletRootIdHintFromWalletStateEnvelope(rawEnvelope?.envelope ?? null),
                 state: null,
                 source: null,
-                unlockUntilUnixMs: null,
                 hasPrimaryStateFile,
                 hasBackupStateFile,
-                hasUnlockSessionFile,
-                message: error instanceof Error ? error.message : String(error),
+                message: "Wallet state exists but was created by an older Cogcoin wallet format that this version no longer loads directly.",
             };
         }
+        const resolvedRoot = await resolveWalletRootIdFromLocalArtifacts({
+            paths,
+            provider,
+        }).catch(() => null);
+        return {
+            availability: "local-state-corrupt",
+            clientPasswordReadiness,
+            unlockRequired: false,
+            walletRootId: resolvedRoot?.walletRootId ?? null,
+            state: null,
+            source: null,
+            hasPrimaryStateFile,
+            hasBackupStateFile,
+            message: clientPasswordReadiness === "migration-required"
+                ? describeClientPasswordMigrationMessage()
+                : describeClientPasswordSetupMessage(),
+        };
     }
     try {
-        const loaded = await normalizeLoadedWalletStateForRead({
-            loaded: await loadWalletState({
-                primaryPath: paths.walletStatePath,
-                backupPath: paths.walletStateBackupPath,
-            }, options.passphrase),
-            access: options.passphrase,
+        const loaded = await loadWalletState({
+            primaryPath: paths.walletStatePath,
+            backupPath: paths.walletStateBackupPath,
+        }, {
+            provider,
+        });
+        const normalized = await normalizeLoadedWalletStateForRead({
+            loaded,
+            access: { provider },
             dataDir: options.dataDir,
             now,
             paths,
         });
         return {
             availability: "ready",
-            walletRootId: loaded.state.walletRootId,
+            clientPasswordReadiness,
+            unlockRequired: false,
+            walletRootId: normalized.state.walletRootId,
             state: normalizeWalletStateRecord({
-                ...loaded.state,
-                miningState: normalizeMiningStateRecord(loaded.state.miningState),
+                ...normalized.state,
+                miningState: normalizeMiningStateRecord(normalized.state.miningState),
             }),
-            source: loaded.source,
-            unlockUntilUnixMs: null,
+            source: normalized.source,
             hasPrimaryStateFile,
             hasBackupStateFile,
-            hasUnlockSessionFile,
             message: null,
         };
     }
     catch (error) {
+        const resolvedRoot = await resolveWalletRootIdFromLocalArtifacts({
+            paths,
+            provider,
+        }).catch(() => null);
+        const message = error instanceof Error ? error.message : String(error);
         return {
             availability: "local-state-corrupt",
-            walletRootId: null,
+            clientPasswordReadiness,
+            unlockRequired: message === "wallet_client_password_locked",
+            walletRootId: resolvedRoot?.walletRootId ?? null,
             state: null,
             source: null,
-            unlockUntilUnixMs: null,
             hasPrimaryStateFile,
             hasBackupStateFile,
-            hasUnlockSessionFile,
-            message: error instanceof Error ? error.message : String(error),
+            message: isWalletAccessError(error)
+                ? describeWalletAccessMessage({ accessError: error })
+                : error instanceof Error
+                    ? error.message
+                    : String(error),
         };
     }
 }
@@ -467,6 +424,7 @@ async function attachNodeStatus(options) {
         if (probe.compatibility !== "compatible" && probe.compatibility !== "unreachable") {
             return {
                 handle: null,
+                rpc: null,
                 status: null,
                 observedStatus: probe.status,
                 error: probe.error,
@@ -500,6 +458,7 @@ async function attachNodeStatus(options) {
         };
         return {
             handle,
+            rpc,
             status,
             observedStatus: serviceStatus ?? null,
             error: null,
@@ -508,18 +467,33 @@ async function attachNodeStatus(options) {
     catch (error) {
         return {
             handle: null,
+            rpc: null,
             status: null,
             observedStatus: null,
             error: error instanceof Error ? error.message : String(error),
         };
     }
 }
+async function readFundingSpendableSats(options) {
+    if (options.state === null || options.rpc === null) {
+        return null;
+    }
+    const state = options.state;
+    try {
+        const utxos = await options.rpc.listUnspent(state.managedCoreWallet.walletName, 1);
+        return utxos.reduce((sum, entry) => isSpendableFundingUtxo(entry, state.funding.scriptPubKeyHex)
+            ? sum + btcAmountToSats(entry.amount)
+            : sum, 0n);
+    }
+    catch {
+        return null;
+    }
+}
 export async function openWalletReadContext(options) {
     const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_SERVICE_START_TIMEOUT_MS;
     const now = options.now ?? Date.now();
     const localState = await inspectWalletLocalState({
         dataDir: options.dataDir,
-        passphrase: options.walletStatePassphrase,
         secretProvider: options.secretProvider,
         walletControlLockHeld: options.walletControlLockHeld,
         now,
@@ -611,6 +585,10 @@ export async function openWalletReadContext(options) {
         now,
         startupError: daemonError,
     });
+    const fundingSpendableSats = await readFundingSpendableSats({
+        state: localState.state,
+        rpc: node.rpc,
+    });
     const mining = await inspectMiningControlPlane({
         provider: options.secretProvider,
         localState,
@@ -634,6 +612,7 @@ export async function openWalletReadContext(options) {
         model: localState.state === null
             ? null
             : createWalletReadModel(localState.state, snapshot),
+        fundingSpendableSats,
         mining,
         async close() {
             await daemonClient?.close().catch(() => undefined);

package/dist/wallet/read/filter.js

@@ -4,20 +4,11 @@ export function isRootDomainName(name) {
 }
 export function isMineableWalletDomain(context, domain) {
     const state = context.localState.state;
-    const model = context.model;
     const snapshot = context.snapshot;
-    if (state === null || model === null || snapshot === null) {
+    if (state === null || context.model === null || snapshot === null) {
         return false;
     }
-    if (!isRootDomainName(domain.name) || domain.anchored !== true || domain.readOnly || domain.ownerLocalIndex === null || domain.domainId === null) {
-        return false;
-    }
-    const localRecord = state.domains.find((entry) => entry.name === domain.name);
-    const ownerIdentity = model.identities.find((identity) => identity.index === domain.ownerLocalIndex);
-    if (localRecord?.currentCanonicalAnchorOutpoint === null
-        || localRecord?.currentCanonicalAnchorOutpoint === undefined
-        || ownerIdentity?.address == null
-        || ownerIdentity.readOnly) {
+    if (!isRootDomainName(domain.name) || domain.anchored !== true || domain.readOnly || domain.localRelationship !== "local" || domain.domainId === null) {
         return false;
     }
     const chainDomain = lookupDomain(snapshot.state, domain.name);

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

@@ -1,4 +1,4 @@
 export { openWalletReadContext, inspectWalletLocalState, readSnapshotWithRetry } from "./context.js";
 export { filterWalletDomains, isMineableWalletDomain, isRootDomainName, type WalletDomainFilterOptions, } from "./filter.js";
 export { createFieldPreview, createWalletReadModel, findDomainField, findWalletLock, findWalletDomain, formatFieldFormat, listDomainFields, listWalletLocks, } from "./project.js";
-export type { WalletBitcoindStatus, WalletDomainDetailsView, WalletDomainView, WalletFieldView, WalletIdentityView, WalletIndexerStatus, WalletLocalStateStatus, WalletLockView, WalletNodeStatus, WalletReadContext, WalletReadModel, WalletServiceHealth, WalletSnapshotView, WalletStateAvailability, } from "./types.js";
+export type { WalletBitcoindStatus, WalletDomainDetailsView, WalletDomainView, WalletFieldView, WalletIndexerStatus, WalletLocalStateStatus, WalletLockView, WalletNodeStatus, WalletReadContext, WalletReadModel, WalletServiceHealth, WalletSnapshotView, WalletStateAvailability, } from "./types.js";