@cogcoin/client 0.5.6 → 0.5.8

package/dist/cli/runner.js

@@ -12,6 +12,14 @@ import { runSyncCommand } from "./commands/sync.js";
 import { runWalletAdminCommand } from "./commands/wallet-admin.js";
 import { runWalletMutationCommand } from "./commands/wallet-mutation.js";
 import { runWalletReadCommand } from "./commands/wallet-read.js";
+import { findWalletSeedRecord, loadWalletSeedIndex } from "../wallet/state/seed-index.js";
+function commandUsesExistingWalletSeed(parsed) {
+    return parsed.seedName !== null
+        && parsed.seedName !== "main"
+        && parsed.command !== "restore"
+        && parsed.command !== "wallet-delete"
+        && parsed.command !== "wallet-restore";
+}
 export async function runCli(argv, contextOverrides = {}) {
     const context = createDefaultContext(contextOverrides);
     let parsed;
@@ -41,6 +49,15 @@ export async function runCli(argv, contextOverrides = {}) {
         return parsed.help ? 0 : 2;
     }
     try {
+        if (commandUsesExistingWalletSeed(parsed)) {
+            const mainPaths = context.resolveWalletRuntimePaths("main");
+            const seedIndex = await loadWalletSeedIndex({
+                paths: mainPaths,
+            });
+            if (seedIndex.seeds.length > 0 && findWalletSeedRecord(seedIndex, parsed.seedName) === null) {
+                throw new Error("wallet_seed_not_found");
+            }
+        }
         if (parsed.command === "sync") {
             return runSyncCommand(parsed, context);
         }
@@ -76,6 +93,7 @@ export async function runCli(argv, contextOverrides = {}) {
             || parsed.command === "wallet-export"
             || parsed.command === "wallet-import"
             || parsed.command === "wallet-init"
+            || parsed.command === "wallet-delete"
             || parsed.command === "wallet-restore"
             || parsed.command === "wallet-show-mnemonic"
             || parsed.command === "wallet-unlock"
@@ -83,7 +101,9 @@ export async function runCli(argv, contextOverrides = {}) {
             return runWalletAdminCommand(parsed, context);
         }
         if (parsed.command === "anchor"
+            || parsed.command === "anchor-clear"
             || parsed.command === "domain-anchor"
+            || parsed.command === "domain-anchor-clear"
             || parsed.command === "register"
             || parsed.command === "domain-register"
             || parsed.command === "transfer"

package/dist/cli/signals.js

@@ -19,7 +19,7 @@ export function createStopSignalWatcher(signalSource, stderr, client, forceExit)
         };
         const onFirstSignal = () => {
             closing = true;
-            writeLine(stderr, "Stopping managed Cogcoin client...");
+            writeLine(stderr, "Detaching from managed Cogcoin client...");
             void client.close().then(() => {
                 settle(0);
             }, () => {

package/dist/cli/types.d.ts

@@ -5,17 +5,17 @@ import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopM
 import { openSqliteStore } from "../sqlite/index.js";
 import type { ClientStoreAdapter } from "../types.js";
 import type { WalletRuntimePaths } from "../wallet/runtime.js";
-import type { exportWallet, WalletPrompter, importWallet, initializeWallet, lockWallet, previewResetWallet, repairWallet, resetWallet, restoreWalletFromMnemonic, showWalletMnemonic, unlockWallet } from "../wallet/lifecycle.js";
+import type { exportWallet, WalletPrompter, importWallet, initializeWallet, deleteImportedWalletSeed, lockWallet, previewResetWallet, repairWallet, resetWallet, restoreWalletFromMnemonic, showWalletMnemonic, unlockWallet } from "../wallet/lifecycle.js";
 import type { openWalletReadContext } from "../wallet/read/index.js";
 import { loadWalletExplicitLock } from "../wallet/state/explicit-lock.js";
 import { loadUnlockSession } from "../wallet/state/session.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
 import type { WalletSecretProvider } from "../wallet/state/provider.js";
 import type { disableMiningHooks, enableMiningHooks, followMiningLog, inspectMiningControlPlane, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining } from "../wallet/mining/index.js";
-import type { anchorDomain, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain } from "../wallet/tx/index.js";
+import type { anchorDomain, clearPendingAnchor, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain } from "../wallet/tx/index.js";
 export type ProgressOutput = "auto" | "tty" | "none";
 export type OutputMode = "text" | "json" | "preview-json";
-export type CommandName = "init" | "restore" | "reset" | "repair" | "sync" | "status" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "indexer-start" | "indexer-stop" | "indexer-status" | "unlock" | "anchor" | "domain-anchor" | "register" | "domain-register" | "transfer" | "domain-transfer" | "sell" | "domain-sell" | "unsell" | "domain-unsell" | "buy" | "domain-buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "field-list" | "field-show" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-send" | "cog-claim" | "cog-reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "cog-balance" | "cog-locks" | "hooks-mining-enable" | "hooks-mining-disable" | "hooks-mining-status" | "mine" | "mine-start" | "mine-stop" | "mine-setup" | "mine-status" | "mine-log" | "wallet-export" | "wallet-import" | "wallet-init" | "wallet-restore" | "wallet-show-mnemonic" | "wallet-lock" | "wallet-unlock" | "wallet-status" | "wallet-address" | "wallet-ids" | "address" | "ids" | "balance" | "locks" | "domain-list" | "domains" | "domain-show" | "show" | "fields" | "field";
+export type CommandName = "init" | "restore" | "reset" | "repair" | "sync" | "status" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "indexer-start" | "indexer-stop" | "indexer-status" | "unlock" | "anchor" | "anchor-clear" | "domain-anchor" | "domain-anchor-clear" | "register" | "domain-register" | "transfer" | "domain-transfer" | "sell" | "domain-sell" | "unsell" | "domain-unsell" | "buy" | "domain-buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "field-list" | "field-show" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-send" | "cog-claim" | "cog-reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "cog-balance" | "cog-locks" | "hooks-mining-enable" | "hooks-mining-disable" | "hooks-mining-status" | "mine" | "mine-start" | "mine-stop" | "mine-setup" | "mine-status" | "mine-log" | "wallet-export" | "wallet-import" | "wallet-init" | "wallet-delete" | "wallet-restore" | "wallet-show-mnemonic" | "wallet-lock" | "wallet-unlock" | "wallet-status" | "wallet-address" | "wallet-ids" | "address" | "ids" | "balance" | "locks" | "domain-list" | "domains" | "domain-show" | "show" | "fields" | "field";
 export interface WritableLike {
     isTTY?: boolean;
     write(chunk: string): void;
@@ -36,6 +36,7 @@ export interface ParsedCliArgs {
     dbPath: string | null;
     dataDir: string | null;
     progressOutput: ProgressOutput;
+    seedName: string | null;
     unlockFor: string | null;
     assumeYes: boolean;
     forceRace: boolean;
@@ -95,6 +96,10 @@ export interface CliRunnerContext {
         dataDir?: string;
         walletRootId?: string;
         progressOutput?: ProgressOutput;
+        confirmGetblockArchiveRestart?: (options: {
+            currentArchiveEndHeight: number | null;
+            nextArchiveEndHeight: number;
+        }) => Promise<boolean>;
     }) => Promise<ManagedClientLike>;
     attachManagedBitcoindService?: typeof attachOrStartManagedBitcoindService;
     probeManagedBitcoindService?: typeof probeManagedBitcoindService;
@@ -115,11 +120,13 @@ export interface CliRunnerContext {
     previewResetWallet?: typeof previewResetWallet;
     exportWallet?: typeof exportWallet;
     importWallet?: typeof importWallet;
+    deleteImportedWalletSeed?: typeof deleteImportedWalletSeed;
     showWalletMnemonic?: typeof showWalletMnemonic;
     unlockWallet?: typeof unlockWallet;
     lockWallet?: typeof lockWallet;
     registerDomain?: typeof registerDomain;
     anchorDomain?: typeof anchorDomain;
+    clearPendingAnchor?: typeof clearPendingAnchor;
     transferDomain?: typeof transferDomain;
     sellDomain?: typeof sellDomain;
     buyDomain?: typeof buyDomain;
@@ -156,7 +163,7 @@ export interface CliRunnerContext {
     readPackageVersion?: () => Promise<string>;
     resolveDefaultBitcoindDataDir?: () => string;
     resolveDefaultClientDatabasePath?: () => string;
-    resolveWalletRuntimePaths?: () => WalletRuntimePaths;
+    resolveWalletRuntimePaths?: (seedName?: string | null) => WalletRuntimePaths;
 }
 export interface StopSignalWatcher {
     cleanup(): void;

package/dist/cli/wallet-format.js

@@ -104,6 +104,12 @@ export function getRepairRecommendation(context) {
     return null;
 }
 export function getMutationRecommendation(context) {
+    const clearableAnchorFamily = (context.localState.state?.proactiveFamilies ?? []).find((family) => family.type === "anchor"
+        && family.status === "draft"
+        && family.currentStep === "reserved");
+    if (clearableAnchorFamily?.domainName != null) {
+        return `Run \`cogcoin anchor clear ${clearableAnchorFamily.domainName}\` to cancel the local pending anchor reservation, or rerun \`cogcoin anchor ${clearableAnchorFamily.domainName}\` to continue anchoring.`;
+    }
     const unresolvedFamily = (context.localState.state?.proactiveFamilies ?? []).find((family) => (family.type === "anchor" || family.type === "field")
         && (family.status === "broadcast-unknown" || family.status === "repair-required"));
     if (unresolvedFamily !== undefined) {

package/dist/wallet/lifecycle.d.ts

@@ -12,7 +12,7 @@ export interface WalletPrompter {
     writeLine(message: string): void;
     prompt(message: string): Promise<string>;
     promptHidden?(message: string): Promise<string>;
-    clearSensitiveDisplay?(scope: "mnemonic-reveal"): void | Promise<void>;
+    clearSensitiveDisplay?(scope: "mnemonic-reveal" | "restore-mnemonic-entry"): void | Promise<void>;
 }
 export interface WalletInitializationResult {
     walletRootId: string;
@@ -42,12 +42,18 @@ export interface WalletImportResult {
     state: WalletStateV1;
 }
 export interface WalletRestoreResult {
+    seedName?: string | null;
     walletRootId: string;
     fundingAddress: string;
     unlockUntilUnixMs: number;
     state: WalletStateV1;
     warnings?: string[];
 }
+export interface WalletDeleteResult {
+    seedName: string;
+    walletRootId: string;
+    deleted: boolean;
+}
 export interface WalletRepairResult {
     walletRootId: string;
     recoveredFromBackup: boolean;
@@ -214,6 +220,17 @@ export declare function restoreWalletFromMnemonic(options: {
     attachService?: typeof attachOrStartManagedBitcoindService;
     rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
 }): Promise<WalletRestoreResult>;
+export declare function deleteImportedWalletSeed(options: {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    probeBitcoindService?: typeof probeManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}): Promise<WalletDeleteResult>;
 export declare function repairWallet(options: {
     dataDir: string;
     databasePath: string;

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,154 @@ 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,
-        });
-        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,
+        const probeManagedBitcoind = options.probeBitcoindService ?? probeManagedBitcoindService;
+        const managedBitcoindProbe = await probeManagedBitcoind({
+            dataDir: options.dataDir,
+            chain: "main",
+            startHeight: 0,
+        }).catch(() => ({
+            compatibility: "unreachable",
+            status: null,
+            error: null,
+        }));
+        if (managedBitcoindProbe.compatibility !== "compatible" && managedBitcoindProbe.compatibility !== "unreachable") {
+            throw new Error(managedBitcoindProbe.error ?? "managed_bitcoind_protocol_error");
+        }
+        if (managedBitcoindProbe.compatibility === "compatible") {
+            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
+                dataDir: options.dataDir,
+                chain: "main",
+                startHeight: 0,
             });
-            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);
+            const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
+            const walletName = sanitizeWalletName(seedRecord.walletRootId);
+            if (rpc.unloadWallet != null) {
+                await rpc.unloadWallet(walletName, false).catch(() => undefined);
             }
-            return {
-                walletRootId,
-                fundingAddress: restoredState.funding.address,
-                unlockUntilUnixMs,
-                state: restoredState,
-                warnings,
-            };
-        }
-        finally {
-            await miningLock.release();
         }
+        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,
+        });
+        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();
-    }
 }