@cogcoin/client 0.5.6 → 0.5.7

package/dist/wallet/lifecycle.js

@@ -11,7 +11,7 @@ import { readPortableWalletArchive, writePortableWalletArchive } from "./archive
 import { normalizeWalletDescriptorState, persistNormalizedWalletDescriptorStateIfNeeded, persistWalletStateUpdate, resolveNormalizedWalletDescriptorState, stripDescriptorChecksum, } from "./descriptor-normalization.js";
 import { acquireFileLock, clearOrphanedFileLock } from "./fs/lock.js";
 import { createInternalCoreWalletPassphrase, createMnemonicConfirmationChallenge, deriveWalletMaterialFromMnemonic, generateWalletMaterial, isEnglishMnemonicWord, validateEnglishMnemonic, } from "./material.js";
-import { resolveWalletRuntimePathsForTesting } from "./runtime.js";
+import { deriveWalletRuntimePathsForSeed, resolveWalletRuntimePathsForTesting, } from "./runtime.js";
 import { requestMiningGenerationPreemption } from "./mining/coordination.js";
 import { loadClientConfig } from "./mining/config.js";
 import { inspectMiningHookState } from "./mining/hooks.js";
@@ -21,6 +21,7 @@ import { renderWalletMnemonicRevealArt } from "./mnemonic-art.js";
 import { clearWalletExplicitLock, loadWalletExplicitLock, saveWalletExplicitLock, } from "./state/explicit-lock.js";
 import { clearWalletPendingInitializationState, loadWalletPendingInitializationStateOrNull, saveWalletPendingInitializationState, } from "./state/pending-init.js";
 import { clearUnlockSession, loadUnlockSession, saveUnlockSession } from "./state/session.js";
+import { addImportedWalletSeedRecord, assertValidImportedWalletSeedName, ensureMainWalletSeedIndexRecord, findWalletSeedRecord, loadWalletSeedIndex, removeWalletSeedRecord, } from "./state/seed-index.js";
 import { createDefaultWalletSecretProvider, createWalletPendingInitSecretReference, createWalletRootId, createWalletSecretReference, } from "./state/provider.js";
 import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, saveWalletState, } from "./state/storage.js";
 export const DEFAULT_UNLOCK_DURATION_MS = 15 * 60 * 1000;
@@ -57,7 +58,7 @@ function resolvePendingInitializationStoragePaths(paths) {
 async function clearPendingInitialization(paths, provider) {
     await clearWalletPendingInitializationState(resolvePendingInitializationStoragePaths(paths), {
         provider,
-        secretReference: createWalletPendingInitSecretReference(paths.stateRoot),
+        secretReference: createWalletPendingInitSecretReference(paths.walletStateRoot),
     });
 }
 async function loadOrCreatePendingInitializationMaterial(options) {
@@ -73,7 +74,7 @@ async function loadOrCreatePendingInitializationMaterial(options) {
         await clearPendingInitialization(options.paths, options.provider);
     }
     const material = generateWalletMaterial();
-    const secretReference = createWalletPendingInitSecretReference(options.paths.stateRoot);
+    const secretReference = createWalletPendingInitSecretReference(options.paths.walletStateRoot);
     const pendingState = {
         schemaVersion: 1,
         createdAtUnixMs: options.nowUnixMs,
@@ -372,7 +373,7 @@ async function promptForArchivePassphrase(prompter, promptPrefix) {
 async function promptForRestoreMnemonic(prompter) {
     const words = [];
     for (let index = 0; index < 24; index += 1) {
-        const word = (await promptHiddenValue(prompter, `Word ${index + 1} of 24: `)).toLowerCase();
+        const word = (await promptRequiredValue(prompter, `Word ${index + 1} of 24: `)).toLowerCase();
         if (!isEnglishMnemonicWord(word)) {
             throw new Error("wallet_restore_mnemonic_invalid");
         }
@@ -405,6 +406,12 @@ async function confirmOverwriteIfNeeded(prompter, path) {
         throw new Error("wallet_export_overwrite_declined");
     }
 }
+async function confirmYesNo(prompter, message) {
+    const answer = (await prompter.prompt(message)).trim().toLowerCase();
+    if (answer !== "yes") {
+        throw new Error("wallet_delete_confirmation_required");
+    }
+}
 async function readManagedSnapshotTip(options) {
     const daemon = await attachOrStartIndexerDaemon({
         dataDir: options.dataDir,
@@ -693,6 +700,16 @@ function createSilentNonInteractivePrompter() {
         },
     };
 }
+function resolveMainWalletPaths(paths) {
+    return deriveWalletRuntimePathsForSeed(paths, "main");
+}
+async function loadSharedWalletSeedIndex(paths, nowUnixMs) {
+    const mainPaths = resolveMainWalletPaths(paths);
+    return await loadWalletSeedIndex({
+        paths: mainPaths,
+        nowUnixMs,
+    });
+}
 function applyRepairStoppedMiningState(state) {
     const miningState = normalizeMiningStateRecord(state.miningState);
     return {
@@ -1125,6 +1142,9 @@ export async function initializeWallet(options) {
     const nowUnixMs = options.nowUnixMs ?? Date.now();
     const unlockDurationMs = options.unlockDurationMs ?? DEFAULT_UNLOCK_DURATION_MS;
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    if (paths.selectedSeedName !== "main") {
+        throw new Error("wallet_init_seed_not_supported");
+    }
     const controlLock = await acquireFileLock(paths.walletControlLockPath, {
         purpose: "wallet-init",
         walletRootId: null,
@@ -1185,6 +1205,11 @@ export async function initializeWallet(options) {
             secretReference,
         });
         await clearPendingInitialization(paths, provider);
+        await ensureMainWalletSeedIndexRecord({
+            paths: resolveMainWalletPaths(paths),
+            walletRootId,
+            nowUnixMs,
+        });
         return {
             walletRootId,
             fundingAddress: verifiedState.funding.address,
@@ -1404,6 +1429,9 @@ export async function importWallet(options) {
     const nowUnixMs = options.nowUnixMs ?? Date.now();
     const unlockDurationMs = options.unlockDurationMs ?? DEFAULT_UNLOCK_DURATION_MS;
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    if (paths.selectedSeedName !== "main") {
+        throw new Error("wallet_import_seed_not_supported");
+    }
     const controlLock = await acquireFileLock(paths.walletControlLockPath, {
         purpose: "wallet-import",
         walletRootId: null,
@@ -1467,6 +1495,11 @@ export async function importWallet(options) {
             databasePath: options.databasePath,
             walletRootId: importedState.walletRootId,
         }).then((daemon) => daemon.close());
+        await ensureMainWalletSeedIndexRecord({
+            paths: resolveMainWalletPaths(paths),
+            walletRootId: importedState.walletRootId,
+            nowUnixMs,
+        });
         return {
             archivePath: options.archivePath,
             walletRootId: importedState.walletRootId,
@@ -1487,98 +1520,129 @@ export async function restoreWalletFromMnemonic(options) {
     const nowUnixMs = options.nowUnixMs ?? Date.now();
     const unlockDurationMs = options.unlockDurationMs ?? DEFAULT_UNLOCK_DURATION_MS;
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const seedName = assertValidImportedWalletSeedName(paths.selectedSeedName);
     const controlLock = await acquireFileLock(paths.walletControlLockPath, {
         purpose: "wallet-restore",
         walletRootId: null,
     });
     try {
-        const rawEnvelope = await loadRawWalletStateEnvelope({
+        const mainPaths = resolveMainWalletPaths(paths);
+        const seedIndex = await loadSharedWalletSeedIndex(paths, nowUnixMs);
+        if (findWalletSeedRecord(seedIndex, "main") === null) {
+            throw new Error("wallet_restore_requires_main_wallet");
+        }
+        if (findWalletSeedRecord(seedIndex, seedName) !== null) {
+            throw new Error("wallet_seed_name_exists");
+        }
+        await ensureWalletNotInitialized(paths, provider);
+        let promptPhaseStarted = false;
+        let mnemonicPhrase;
+        try {
+            promptPhaseStarted = true;
+            mnemonicPhrase = await promptForRestoreMnemonic(options.prompter);
+        }
+        finally {
+            if (promptPhaseStarted) {
+                await options.prompter.clearSensitiveDisplay?.("restore-mnemonic-entry");
+            }
+        }
+        await clearPendingInitialization(paths, provider);
+        const material = deriveWalletMaterialFromMnemonic(mnemonicPhrase);
+        const walletRootId = createWalletRootId();
+        const internalCoreWalletPassphrase = createInternalCoreWalletPassphrase();
+        const secretReference = createWalletSecretReference(walletRootId);
+        const secret = randomBytes(32);
+        await provider.storeSecret(secretReference.keyId, secret);
+        const initialState = createInitialWalletState({
+            walletRootId,
+            nowUnixMs,
+            material,
+            internalCoreWalletPassphrase,
+        });
+        await clearUnlockSession(paths.walletUnlockSessionPath);
+        await clearWalletExplicitLock(paths.walletExplicitLockPath);
+        await saveWalletState({
             primaryPath: paths.walletStatePath,
             backupPath: paths.walletStateBackupPath,
+        }, initialState, {
+            provider,
+            secretReference,
+        });
+        const restoredState = await recreateManagedCoreWalletReplica(initialState, provider, paths, options.dataDir, nowUnixMs, {
+            attachService: options.attachService,
+            rpcFactory: options.rpcFactory,
+        });
+        const unlockUntilUnixMs = nowUnixMs + unlockDurationMs;
+        await clearWalletExplicitLock(paths.walletExplicitLockPath);
+        await saveUnlockSession(paths.walletUnlockSessionPath, createUnlockSession(restoredState, unlockUntilUnixMs, secretReference.keyId, nowUnixMs), {
+            provider,
+            secretReference,
         });
-        const replacementStateExists = rawEnvelope !== null
-            || await pathExists(paths.walletStatePath)
-            || await pathExists(paths.walletStateBackupPath);
-        const replacementCoreWalletExists = await detectExistingManagedWalletReplica(options.dataDir);
-        const mnemonicPhrase = await promptForRestoreMnemonic(options.prompter);
         await clearPendingInitialization(paths, provider);
-        if (replacementStateExists || replacementCoreWalletExists) {
-            await confirmRestoreReplacement(options.prompter);
+        await addImportedWalletSeedRecord({
+            paths: mainPaths,
+            seedName,
+            walletRootId,
+            nowUnixMs,
+        });
+        return {
+            seedName,
+            walletRootId,
+            fundingAddress: restoredState.funding.address,
+            unlockUntilUnixMs,
+            state: restoredState,
+            warnings: [],
+        };
+    }
+    finally {
+        await controlLock.release();
+    }
+}
+export async function deleteImportedWalletSeed(options) {
+    const provider = options.provider ?? createDefaultWalletSecretProvider();
+    const nowUnixMs = options.nowUnixMs ?? Date.now();
+    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    if ((paths.selectedSeedName ?? "main") === "main") {
+        throw new Error("wallet_delete_main_not_supported");
+    }
+    const seedName = assertValidImportedWalletSeedName(paths.selectedSeedName);
+    const controlLock = await acquireFileLock(paths.walletControlLockPath, {
+        purpose: "wallet-delete",
+        walletRootId: null,
+    });
+    try {
+        const mainPaths = resolveMainWalletPaths(paths);
+        const seedIndex = await loadSharedWalletSeedIndex(paths, nowUnixMs);
+        const seedRecord = findWalletSeedRecord(seedIndex, seedName);
+        if (seedRecord === null) {
+            throw new Error("wallet_seed_not_found");
         }
-        let previousWalletRootId = extractWalletRootIdHintFromWalletStateEnvelope(rawEnvelope?.envelope ?? null);
-        try {
-            const loaded = await loadWalletState({
-                primaryPath: paths.walletStatePath,
-                backupPath: paths.walletStateBackupPath,
-            }, {
-                provider,
-            });
-            previousWalletRootId = loaded.state.walletRootId;
+        if (seedRecord.kind !== "imported") {
+            throw new Error("wallet_delete_main_not_supported");
         }
-        catch {
-            previousWalletRootId = previousWalletRootId ?? null;
+        if (!options.assumeYes) {
+            await confirmYesNo(options.prompter, `Delete imported seed "${seedName}" and release its local wallet artifacts? Type yes to continue: `);
         }
-        const miningLock = await acquireFileLock(paths.miningControlLockPath, {
-            purpose: "wallet-restore",
-            walletRootId: previousWalletRootId,
+        await clearUnlockSession(paths.walletUnlockSessionPath).catch(() => undefined);
+        await clearWalletExplicitLock(paths.walletExplicitLockPath).catch(() => undefined);
+        await clearPendingInitialization(paths, provider).catch(() => undefined);
+        await provider.deleteSecret(createWalletSecretReference(seedRecord.walletRootId).keyId).catch(() => undefined);
+        await rm(paths.walletStateRoot, { recursive: true, force: true }).catch(() => undefined);
+        await rm(paths.walletRuntimeRoot, { recursive: true, force: true }).catch(() => undefined);
+        await rm(join(options.dataDir, "wallets", sanitizeWalletName(seedRecord.walletRootId)), {
+            recursive: true,
+            force: true,
+        }).catch(() => undefined);
+        await removeWalletSeedRecord({
+            paths: mainPaths,
+            seedName,
+            nowUnixMs,
         });
-        try {
-            const warnings = [];
-            const material = deriveWalletMaterialFromMnemonic(mnemonicPhrase);
-            const walletRootId = createWalletRootId();
-            const internalCoreWalletPassphrase = createInternalCoreWalletPassphrase();
-            const secretReference = createWalletSecretReference(walletRootId);
-            const secret = randomBytes(32);
-            await provider.storeSecret(secretReference.keyId, secret);
-            const initialState = createInitialWalletState({
-                walletRootId,
-                nowUnixMs,
-                material,
-                internalCoreWalletPassphrase,
-            });
-            await clearUnlockSession(paths.walletUnlockSessionPath);
-            await clearWalletExplicitLock(paths.walletExplicitLockPath);
-            await saveWalletState({
-                primaryPath: paths.walletStatePath,
-                backupPath: paths.walletStateBackupPath,
-            }, initialState, {
-                provider,
-                secretReference,
-            });
-            const restoredState = await recreateManagedCoreWalletReplica(initialState, provider, paths, options.dataDir, nowUnixMs, {
-                attachService: options.attachService,
-                rpcFactory: options.rpcFactory,
-            });
-            const unlockUntilUnixMs = nowUnixMs + unlockDurationMs;
-            await clearWalletExplicitLock(paths.walletExplicitLockPath);
-            await saveUnlockSession(paths.walletUnlockSessionPath, createUnlockSession(restoredState, unlockUntilUnixMs, secretReference.keyId, nowUnixMs), {
-                provider,
-                secretReference,
-            });
-            await clearPendingInitialization(paths, provider);
-            if (previousWalletRootId !== null && previousWalletRootId !== walletRootId) {
-                try {
-                    await clearPreviousManagedWalletRuntime({
-                        dataDir: options.dataDir,
-                        walletRootId: previousWalletRootId,
-                    });
-                }
-                catch (error) {
-                    warnings.push(formatRestoreCleanupWarning(error));
-                }
-                await provider.deleteSecret(createWalletSecretReference(previousWalletRootId).keyId).catch(() => undefined);
-            }
-            return {
-                walletRootId,
-                fundingAddress: restoredState.funding.address,
-                unlockUntilUnixMs,
-                state: restoredState,
-                warnings,
-            };
-        }
-        finally {
-            await miningLock.release();
-        }
+        return {
+            seedName,
+            walletRootId: seedRecord.walletRootId,
+            deleted: true,
+        };
     }
     finally {
         await controlLock.release();

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

@@ -1,9 +1,10 @@
-import type { ProgressOutputMode } from "../../bitcoind/types.js";
+import type { BootstrapProgress, ProgressOutputMode } from "../../bitcoind/types.js";
+import { createFollowSceneState } from "../../bitcoind/progress/follow-scene.js";
+import { type RenderClock, type TtyRenderStream } from "../../bitcoind/progress/render-policy.js";
 import type { MiningRuntimeStatusV1 } from "./types.js";
-interface RenderStream {
-    isTTY?: boolean;
-    columns?: number;
-    write(chunk: string): boolean | void;
+interface VisualizerRendererLike {
+    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: ReturnType<typeof createFollowSceneState>, statusFieldText?: string): void;
+    close(): void;
 }
 export declare function describeMiningVisualizerStatus(snapshot: MiningRuntimeStatusV1): string;
 export declare function describeMiningVisualizerProgress(snapshot: MiningRuntimeStatusV1): string;
@@ -11,7 +12,11 @@ export declare class MiningFollowVisualizer {
     #private;
     constructor(options?: {
         progressOutput?: ProgressOutputMode;
-        stream?: RenderStream;
+        stream?: TtyRenderStream;
+        platform?: NodeJS.Platform;
+        env?: NodeJS.ProcessEnv;
+        clock?: RenderClock;
+        rendererFactory?: (stream: TtyRenderStream) => VisualizerRendererLike;
     });
     update(snapshot: MiningRuntimeStatusV1): void;
     close(): void;

package/dist/wallet/mining/visualizer.js

@@ -1,5 +1,6 @@
 import { createBootstrapProgress } from "../../bitcoind/progress/formatting.js";
 import { createFollowSceneState, 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 VISUALIZER_PROGRESS_SNAPSHOT = {
     url: "",
@@ -8,15 +9,6 @@ const VISUALIZER_PROGRESS_SNAPSHOT = {
     sha256: "",
     sizeBytes: 1,
 };
-function shouldRenderToTty(progressOutput, stream) {
-    if (progressOutput === "none") {
-        return false;
-    }
-    if (progressOutput === "tty") {
-        return true;
-    }
-    return stream.isTTY === true;
-}
 export function describeMiningVisualizerStatus(snapshot) {
     switch (snapshot.currentPhase) {
         case "resuming":
@@ -99,24 +91,52 @@ export function describeMiningVisualizerProgress(snapshot) {
 }
 export class MiningFollowVisualizer {
     #renderer;
+    #clock;
+    #renderThrottle;
     #progress = createBootstrapProgress("follow_tip", VISUALIZER_PROGRESS_SNAPSHOT);
     #scene = createFollowSceneState();
+    #latestSnapshot = null;
     constructor(options = {}) {
         const stream = options.stream ?? process.stderr;
         const progressOutput = options.progressOutput ?? "auto";
-        this.#renderer = shouldRenderToTty(progressOutput, stream)
-            ? new TtyProgressRenderer(stream)
+        const renderPolicy = resolveTtyRenderPolicy(progressOutput, stream, {
+            platform: options.platform,
+            env: options.env,
+        });
+        this.#clock = options.clock ?? DEFAULT_RENDER_CLOCK;
+        this.#renderer = renderPolicy.enabled
+            ? options.rendererFactory?.(stream) ?? new TtyProgressRenderer(stream)
             : null;
+        this.#renderThrottle = new TtyRenderThrottle({
+            clock: this.#clock,
+            intervalMs: renderPolicy.repaintIntervalMs,
+            onRender: () => {
+                this.#renderLatestSnapshot();
+            },
+            throttled: renderPolicy.linuxHeadlessThrottle,
+        });
     }
     update(snapshot) {
         if (this.#renderer === null) {
             return;
         }
+        this.#latestSnapshot = snapshot;
+        this.#renderThrottle.request();
+    }
+    close() {
+        this.#renderThrottle.flush();
+        this.#renderer?.close();
+    }
+    #renderLatestSnapshot() {
+        if (this.#renderer === null || this.#latestSnapshot === null) {
+            return;
+        }
+        const snapshot = this.#latestSnapshot;
         const indexedHeight = snapshot.indexerTipHeight ?? snapshot.coreBestHeight ?? null;
         const nodeHeight = snapshot.coreBestHeight ?? indexedHeight;
         this.#progress.phase = "follow_tip";
         this.#progress.message = describeMiningVisualizerProgress(snapshot);
-        this.#progress.updatedAt = Date.now();
+        this.#progress.updatedAt = this.#clock.now();
         this.#progress.blocks = nodeHeight;
         this.#progress.targetHeight = nodeHeight;
         this.#progress.etaSeconds = null;
@@ -128,7 +148,4 @@ export class MiningFollowVisualizer {
         });
         this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot));
     }
-    close() {
-        this.#renderer?.close();
-    }
 }

package/dist/wallet/reset.js

@@ -13,6 +13,7 @@ import { loadMiningRuntimeStatus } from "./mining/runtime-artifacts.js";
 import { resolveWalletRuntimePathsForTesting } from "./runtime.js";
 import { loadWalletExplicitLock } from "./state/explicit-lock.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) {
@@ -519,6 +520,12 @@ 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))];
     return {
         dataRoot: options.paths.dataRoot,
         removedRoots,
@@ -531,6 +538,7 @@ async function preflightReset(options) {
                     : "passphrase-wrapped",
             envelopeSource: rawEnvelope?.source ?? null,
             secretProviderKeyId,
+            importedSeedSecretProviderKeyIds,
             explicitLock,
             rawEnvelope,
         },
@@ -719,7 +727,8 @@ export async function previewResetWallet(options) {
                 : null,
         },
         trackedProcessKinds: preflight.trackedProcessKinds,
-        willDeleteOsSecrets: preflight.wallet.secretProviderKeyId !== null,
+        willDeleteOsSecrets: preflight.wallet.secretProviderKeyId !== null
+            || preflight.wallet.importedSeedSecretProviderKeyIds.length > 0,
         removedPaths,
     };
 }
@@ -766,9 +775,7 @@ export async function resetWallet(options) {
     let rootsDeleted = false;
     let committed = false;
     let newProviderKeyId = null;
-    let secretCleanupStatus = preflight.wallet.secretProviderKeyId === null
-        ? "not-found"
-        : "not-found";
+    let secretCleanupStatus = "not-found";
     const deletedSecretRefs = [];
     const failedSecretRefs = [];
     const preservedSecretRefs = [];
@@ -850,41 +857,46 @@ export async function resetWallet(options) {
             await restoreStagedArtifacts(stagedSnapshotArtifacts);
         }
         committed = true;
-        if (walletAction === "deleted") {
-            if (preflight.wallet.secretProviderKeyId !== null) {
-                try {
-                    await provider.deleteSecret(preflight.wallet.secretProviderKeyId);
-                    deletedSecretRefs.push(preflight.wallet.secretProviderKeyId);
-                    secretCleanupStatus = "deleted";
-                }
-                catch {
-                    failedSecretRefs.push(preflight.wallet.secretProviderKeyId);
-                    secretCleanupStatus = "failed";
-                    throw new Error("reset_secret_cleanup_failed");
-                }
-            }
-        }
-        else if (walletAction === "retain-mnemonic" && preflight.wallet.secretProviderKeyId !== null) {
+        const deleteTrackedSecretReference = async (keyId) => {
             try {
-                if (preflight.wallet.secretProviderKeyId !== newProviderKeyId) {
-                    await provider.deleteSecret(preflight.wallet.secretProviderKeyId);
-                    deletedSecretRefs.push(preflight.wallet.secretProviderKeyId);
-                    secretCleanupStatus = "deleted";
-                }
+                await provider.deleteSecret(keyId);
+                deletedSecretRefs.push(keyId);
             }
             catch {
-                failedSecretRefs.push(preflight.wallet.secretProviderKeyId);
+                failedSecretRefs.push(keyId);
                 secretCleanupStatus = "failed";
                 throw new Error("reset_secret_cleanup_failed");
             }
+        };
+        for (const importedSecretKeyId of preflight.wallet.importedSeedSecretProviderKeyIds) {
+            await deleteTrackedSecretReference(importedSecretKeyId);
+        }
+        if (walletAction === "deleted") {
+            if (preflight.wallet.secretProviderKeyId !== null) {
+                await deleteTrackedSecretReference(preflight.wallet.secretProviderKeyId);
+            }
+        }
+        else if (walletAction === "retain-mnemonic" && preflight.wallet.secretProviderKeyId !== null) {
+            if (preflight.wallet.secretProviderKeyId !== newProviderKeyId) {
+                await deleteTrackedSecretReference(preflight.wallet.secretProviderKeyId);
+            }
         }
         else if (preflight.wallet.secretProviderKeyId !== null) {
             preservedSecretRefs.push(preflight.wallet.secretProviderKeyId);
         }
-        if (preflight.wallet.secretProviderKeyId === null && preflight.wallet.present && preflight.wallet.rawEnvelope === null) {
+        if (failedSecretRefs.length > 0) {
+            secretCleanupStatus = "failed";
+        }
+        else if (deletedSecretRefs.length > 0) {
+            secretCleanupStatus = "deleted";
+        }
+        else if (preflight.wallet.secretProviderKeyId === null
+            && preflight.wallet.importedSeedSecretProviderKeyIds.length === 0
+            && preflight.wallet.present
+            && preflight.wallet.rawEnvelope === null) {
             secretCleanupStatus = "unknown";
         }
-        else if (deletedSecretRefs.length === 0 && failedSecretRefs.length === 0) {
+        else if (deletedSecretRefs.length === 0) {
             secretCleanupStatus = "not-found";
         }
         return {

package/dist/wallet/runtime.d.ts

@@ -1,13 +1,23 @@
 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;
     clientDataDir: string;
     clientConfigPath: string;
     runtimeRoot: string;
+    walletRuntimeRoot: string;
     hooksRoot: string;
     stateRoot: string;
+    walletStateRoot: string;
+    seedRegistryPath: string;
+    selectedSeedName: string;
+    selectedSeedKind: WalletSeedKind;
     bitcoinDataDir: string;
     indexerRoot: string;
+    walletStateDirectory: string;
     walletStatePath: string;
     walletStateBackupPath: string;
     walletInitPendingPath: string;
@@ -27,4 +37,5 @@ export interface WalletRuntimePaths {
     miningEventsPath: string;
     miningControlLockPath: string;
 }
-export declare function resolveWalletRuntimePathsForTesting(resolution?: CogcoinPathResolution): WalletRuntimePaths;
+export declare function deriveWalletRuntimePathsForSeed(basePaths: WalletRuntimePaths, seedName: string | null | undefined): WalletRuntimePaths;
+export declare function resolveWalletRuntimePathsForTesting(resolution?: WalletRuntimePathResolution): WalletRuntimePaths;