@cogcoin/client 1.1.4 → 1.1.5

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/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;
     };

package/dist/wallet/reset.js

@@ -14,7 +14,6 @@ import { loadMiningRuntimeStatus } from "./mining/runtime-artifacts.js";
 import { clearLegacyWalletLockArtifacts, withUnlockedManagedCoreWallet } from "./managed-core-wallet.js";
 import { resolveWalletRuntimePathsForTesting } from "./runtime.js";
 import { createDefaultWalletSecretProvider, createWalletRootId, createWalletSecretReference, } from "./state/provider.js";
-import { loadWalletSeedIndex } from "./state/seed-index.js";
 import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, saveWalletState, } from "./state/storage.js";
 import { confirmTypedAcknowledgement } from "./tx/confirm.js";
 function sanitizeWalletName(walletRootId) {
@@ -50,6 +49,36 @@ async function readJsonFileOrNull(path) {
         return null;
     }
 }
+async function collectLegacyImportedSeedSecretProviderKeyIds(paths) {
+    const seedsRoot = join(paths.stateRoot, "seeds");
+    const entries = await readdir(seedsRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    const keyIds = new Set();
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const seedRoot = join(seedsRoot, entry.name);
+        const candidatePaths = [
+            join(seedRoot, "wallet-state.enc"),
+            join(seedRoot, "wallet-state.enc.bak"),
+            join(seedRoot, "wallet-init-pending.enc"),
+            join(seedRoot, "wallet-init-pending.enc.bak"),
+        ];
+        for (const candidatePath of candidatePaths) {
+            const envelope = await readJsonFileOrNull(candidatePath);
+            const keyId = envelope?.secretProvider?.keyId?.trim() ?? "";
+            if (keyId.length > 0) {
+                keyIds.add(keyId);
+            }
+        }
+    }
+    return [...keyIds].sort((left, right) => left.localeCompare(right));
+}
 async function isProcessAlive(pid) {
     if (pid === null) {
         return false;
@@ -454,12 +483,7 @@ async function preflightReset(options) {
     }
     const tracked = await collectTrackedManagedProcesses(options.paths);
     const secretProviderKeyId = rawEnvelope?.envelope.secretProvider?.keyId ?? null;
-    const seedIndex = await loadWalletSeedIndex({
-        paths: options.paths,
-    }).catch(() => null);
-    const importedSeedSecretProviderKeyIds = [...new Set((seedIndex?.seeds ?? [])
-            .filter((seed) => seed.kind === "imported")
-            .map((seed) => createWalletSecretReference(seed.walletRootId).keyId))];
+    const importedSeedSecretProviderKeyIds = await collectLegacyImportedSeedSecretProviderKeyIds(options.paths);
     return {
         dataRoot: options.paths.dataRoot,
         removedRoots,
@@ -555,8 +579,8 @@ async function resolveResetExecutionDecision(options) {
     let walletChoice = "";
     let loadedWalletForEntropyReset = null;
     if (options.preflight.wallet.present) {
-        const answer = (await options.prompter.prompt("Wallet reset choice ([Enter] retain base entropy, \"skip\", or \"delete wallet\"): ")).trim();
-        if (answer !== "" && answer !== "skip" && answer !== "delete wallet") {
+        const answer = (await options.prompter.prompt("Wallet reset choice ([Enter] retain base entropy, \"skip\", or \"clear wallet entropy\"): ")).trim();
+        if (answer !== "" && answer !== "skip" && answer !== "clear wallet entropy") {
             throw new Error("reset_wallet_choice_invalid");
         }
         walletChoice = answer;
@@ -592,7 +616,7 @@ function determineWalletAction(walletPresent, walletChoice) {
     if (walletChoice === "skip") {
         return "kept-unchanged";
     }
-    if (walletChoice === "delete wallet") {
+    if (walletChoice === "clear wallet entropy") {
         return "deleted";
     }
     return "retain-mnemonic";
@@ -636,7 +660,7 @@ export async function previewResetWallet(options) {
         walletPrompt: preflight.wallet.present
             ? {
                 defaultAction: "retain-mnemonic",
-                acceptedInputs: ["", "skip", "delete wallet"],
+                acceptedInputs: ["", "skip", "clear wallet entropy"],
                 entropyRetainingResetAvailable: preflight.wallet.mode === "provider-backed",
                 envelopeSource: preflight.wallet.envelopeSource,
             }

package/dist/wallet/runtime.d.ts

@@ -1,7 +1,5 @@
 import type { CogcoinPathResolution } from "../app-paths.js";
-export type WalletSeedKind = "main" | "imported";
 export interface WalletRuntimePathResolution extends CogcoinPathResolution {
-    seedName?: string | null;
 }
 export interface WalletRuntimePaths {
     dataRoot: string;
@@ -11,9 +9,6 @@ export interface WalletRuntimePaths {
     walletRuntimeRoot: string;
     stateRoot: string;
     walletStateRoot: string;
-    seedRegistryPath: string;
-    selectedSeedName: string;
-    selectedSeedKind: WalletSeedKind;
     bitcoinDataDir: string;
     indexerRoot: string;
     walletStateDirectory: string;
@@ -31,5 +26,4 @@ export interface WalletRuntimePaths {
     miningEventsPath: string;
     miningControlLockPath: string;
 }
-export declare function deriveWalletRuntimePathsForSeed(basePaths: WalletRuntimePaths, seedName: string | null | undefined): WalletRuntimePaths;
 export declare function resolveWalletRuntimePathsForTesting(resolution?: WalletRuntimePathResolution): WalletRuntimePaths;

package/dist/wallet/runtime.js

@@ -1,41 +1,8 @@
 import { join } from "node:path";
 import { resolveCogcoinPathsForTesting } from "../app-paths.js";
-function resolveSeedLayout(sharedStateRoot, sharedRuntimeRoot, seedName) {
-    if (seedName === "main") {
-        return {
-            seedKind: "main",
-            walletStateRoot: sharedStateRoot,
-            walletRuntimeRoot: sharedRuntimeRoot,
-        };
-    }
-    return {
-        seedKind: "imported",
-        walletStateRoot: join(sharedStateRoot, "seeds", seedName),
-        walletRuntimeRoot: join(sharedRuntimeRoot, "seeds", seedName),
-    };
-}
-export function deriveWalletRuntimePathsForSeed(basePaths, seedName) {
-    const resolvedSeedName = seedName ?? "main";
-    const seedLayout = resolveSeedLayout(basePaths.stateRoot, basePaths.runtimeRoot, resolvedSeedName);
-    return {
-        ...basePaths,
-        walletRuntimeRoot: seedLayout.walletRuntimeRoot,
-        walletStateRoot: seedLayout.walletStateRoot,
-        selectedSeedName: resolvedSeedName,
-        selectedSeedKind: seedLayout.seedKind,
-        walletStateDirectory: seedLayout.walletStateRoot,
-        walletStatePath: join(seedLayout.walletStateRoot, "wallet-state.enc"),
-        walletStateBackupPath: join(seedLayout.walletStateRoot, "wallet-state.enc.bak"),
-        walletInitPendingPath: join(seedLayout.walletStateRoot, "wallet-init-pending.enc"),
-        walletInitPendingBackupPath: join(seedLayout.walletStateRoot, "wallet-init-pending.enc.bak"),
-        miningRoot: join(seedLayout.walletRuntimeRoot, "mining"),
-        miningStatusPath: join(seedLayout.walletRuntimeRoot, "mining", "status.json"),
-        miningEventsPath: join(seedLayout.walletRuntimeRoot, "mining", "events.jsonl"),
-    };
-}
 export function resolveWalletRuntimePathsForTesting(resolution = {}) {
     const paths = resolveCogcoinPathsForTesting(resolution);
-    return deriveWalletRuntimePathsForSeed({
+    return {
         dataRoot: paths.dataRoot,
         clientDataDir: paths.clientDataDir,
         clientConfigPath: paths.clientConfigPath,
@@ -43,9 +10,6 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
         walletRuntimeRoot: paths.runtimeRoot,
         stateRoot: paths.stateRoot,
         walletStateRoot: paths.stateRoot,
-        seedRegistryPath: join(paths.stateRoot, "seed-index.json"),
-        selectedSeedName: "main",
-        selectedSeedKind: "main",
         bitcoinDataDir: paths.bitcoinDataDir,
         indexerRoot: paths.indexerRoot,
         walletStateDirectory: paths.stateRoot,
@@ -62,5 +26,5 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
         miningStatusPath: join(paths.runtimeRoot, "mining", "status.json"),
         miningEventsPath: join(paths.runtimeRoot, "mining", "events.jsonl"),
         miningControlLockPath: paths.miningControlLockPath,
-    }, resolution.seedName);
+    };
 }

package/dist/wallet/tx/common.d.ts

@@ -168,6 +168,24 @@ export declare function buildWalletMutationTransaction<TPlan>(options: {
     availableFundingMinConf?: number;
     temporarilyUnlockedPolicyOutpoints?: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;
+export declare function fundAndValidateWalletMutationDraft<TPlan>(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    plan: TPlan & {
+        fixedInputs: FixedWalletInput[];
+        outputs: unknown[];
+        changeAddress: string;
+        changePosition?: number | null;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
+    };
+    validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
+    feeRate?: number;
+    availableFundingMinConf?: number;
+}): Promise<{
+    funded: RpcWalletCreateFundedPsbtResult;
+    decoded: RpcDecodedPsbt;
+}>;
 export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>(options: {
     rpc: WalletMutationRpcClient;
     walletName: string;

package/dist/wallet/tx/common.js

@@ -416,35 +416,16 @@ export async function pauseMiningForWalletMutation(options) {
     });
 }
 export async function buildWalletMutationTransaction(options) {
-    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
-    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
-        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
-    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
-        outpointKey({ txid: entry.txid, vout: entry.vout }),
-        btcNumberToSats(entry.amount),
-    ]));
-    const validationPlan = {
-        ...options.plan,
-        eligibleFundingOutpointKeys: new Set([
-            ...options.plan.eligibleFundingOutpointKeys,
-            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
-        ]),
-    };
     const temporaryBuilderLockedOutpoints = [];
     try {
-        const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
-            add_inputs: true,
-            include_unsafe: false,
-            minconf: availableFundingMinConf,
-            changeAddress: options.plan.changeAddress,
-            ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
-            lockUnspents: false,
-            fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
-            replaceable: true,
-            subtractFeeFromOutputs: [],
+        const { funded, decoded } = await fundAndValidateWalletMutationDraft({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            plan: options.plan,
+            validateFundedDraft: options.validateFundedDraft,
+            feeRate: options.feeRate,
+            availableFundingMinConf: options.availableFundingMinConf,
         });
-        const decoded = await options.rpc.decodePsbt(funded.psbt);
-        options.validateFundedDraft(decoded, funded, validationPlan);
         let signed;
         let finalized;
         let rawHex;
@@ -490,6 +471,39 @@ export async function buildWalletMutationTransaction(options) {
         throw error;
     }
 }
+export async function fundAndValidateWalletMutationDraft(options) {
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
+    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
+        outpointKey({ txid: entry.txid, vout: entry.vout }),
+        btcNumberToSats(entry.amount),
+    ]));
+    const validationPlan = {
+        ...options.plan,
+        eligibleFundingOutpointKeys: new Set([
+            ...options.plan.eligibleFundingOutpointKeys,
+            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
+        ]),
+    };
+    const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
+        add_inputs: true,
+        include_unsafe: false,
+        minconf: availableFundingMinConf,
+        changeAddress: options.plan.changeAddress,
+        ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
+        lockUnspents: false,
+        fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
+        replaceable: true,
+        subtractFeeFromOutputs: [],
+    });
+    const decoded = await options.rpc.decodePsbt(funded.psbt);
+    options.validateFundedDraft(decoded, funded, validationPlan);
+    return {
+        funded,
+        decoded,
+    };
+}
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
     return buildWalletMutationTransaction({
         rpc: options.rpc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",

package/dist/wallet/state/seed-index.d.ts

@@ -1,43 +0,0 @@
-import type { WalletSeedKind, WalletRuntimePaths } from "../runtime.js";
-import { type RawWalletStateEnvelope } from "./storage.js";
-export interface WalletSeedRecord {
-    name: string;
-    kind: WalletSeedKind;
-    walletRootId: string;
-    createdAtUnixMs: number;
-    restoredAtUnixMs: number | null;
-}
-export interface WalletSeedIndexV1 {
-    schemaVersion: 1;
-    lastWrittenAtUnixMs: number;
-    seeds: WalletSeedRecord[];
-}
-export declare function normalizeWalletSeedName(name: string): string;
-export declare function isValidWalletSeedName(name: string): boolean;
-export declare function assertValidImportedWalletSeedName(name: string): string;
-export declare function findWalletSeedRecord(index: WalletSeedIndexV1, seedName: string): WalletSeedRecord | null;
-export declare function loadWalletSeedIndex(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    nowUnixMs?: number;
-    loadRawWalletStateEnvelope?: (paths: {
-        primaryPath: string;
-        backupPath: string;
-    }) => Promise<RawWalletStateEnvelope | null>;
-}): Promise<WalletSeedIndexV1>;
-export declare function saveWalletSeedIndex(paths: Pick<WalletRuntimePaths, "seedRegistryPath">, index: WalletSeedIndexV1): Promise<void>;
-export declare function ensureMainWalletSeedIndexRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    walletRootId: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;
-export declare function addImportedWalletSeedRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    seedName: string;
-    walletRootId: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;
-export declare function removeWalletSeedRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    seedName: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;