@cogcoin/client 1.1.3 → 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/read/context.d.ts

@@ -1,6 +1,6 @@
 import { readSnapshotWithRetry } from "../../bitcoind/indexer-daemon.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { WalletLocalStateStatus, WalletReadContext } from "./types.js";
+import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletReadContext, WalletServiceHealth } from "./types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 declare function inspectWalletLocalState(options?: {
     dataDir?: string;
@@ -9,6 +9,10 @@ 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;

package/dist/wallet/read/context.js

@@ -20,6 +20,9 @@ import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMes
 import { createWalletReadModel } from "./project.js";
 const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
 const STALE_HEARTBEAT_THRESHOLD_MS = 15_000;
+const TOLERATED_NODE_HEADER_LEAD_BLOCKS = 2;
+const TOLERATED_NODE_HEADER_LEAD_MESSAGE = "Bitcoin headers can briefly lead validated blocks; a short 1-2 block lead is normal and is being tolerated.";
+const NODE_CATCHING_UP_MESSAGE = "Bitcoin Core is still catching up to headers.";
 function btcAmountToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
@@ -351,14 +354,23 @@ function deriveBitcoindHealth(options) {
 function deriveNodeHealth(status, bitcoindHealth) {
     if (bitcoindHealth !== "ready" || status === null || !status.ready) {
         return {
-            health: "unavailable",
-            message: "Bitcoin service is unavailable.",
+            health: "catching-up",
+            message: NODE_CATCHING_UP_MESSAGE,
         };
     }
-    if (status.nodeBestHeight !== null && status.nodeHeaderHeight !== null && status.nodeBestHeight < status.nodeHeaderHeight) {
+    const headerLead = status.nodeBestHeight !== null && status.nodeHeaderHeight !== null
+        ? status.nodeHeaderHeight - status.nodeBestHeight
+        : null;
+    if (headerLead !== null && headerLead > 0) {
+        if (headerLead <= TOLERATED_NODE_HEADER_LEAD_BLOCKS) {
+            return {
+                health: "synced",
+                message: TOLERATED_NODE_HEADER_LEAD_MESSAGE,
+            };
+        }
         return {
             health: "catching-up",
-            message: "Bitcoin Core is still catching up to headers.",
+            message: NODE_CATCHING_UP_MESSAGE,
         };
     }
     return {
@@ -366,6 +378,9 @@ function deriveNodeHealth(status, bitcoindHealth) {
         message: null,
     };
 }
+export function deriveNodeHealthForTesting(status, bitcoindHealth) {
+    return deriveNodeHealth(status, bitcoindHealth);
+}
 function deriveIndexerHealth(options) {
     const daemonStatus = options.source === "lease"
         ? options.daemonStatus

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;