@cogcoin/client 1.1.6 → 1.1.8

package/dist/wallet/reset/preflight.js

@@ -0,0 +1,116 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { DEFAULT_SNAPSHOT_METADATA } from "../../bitcoind/bootstrap/constants.js";
+import { resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap/paths.js";
+import { validateSnapshotFileForTesting } from "../../bitcoind/bootstrap/snapshot-file.js";
+import { loadRawWalletStateEnvelope, } from "../state/storage.js";
+import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
+import { isDeletedByRemovalPlan, pathExists, readJsonFileOrNull, resolveRemovedRoots, } from "./artifacts.js";
+import { collectTrackedManagedProcesses } from "./process-cleanup.js";
+function providerUsesExternalSecretStore(provider) {
+    return provider.kind === "macos-keychain";
+}
+export function resetDeletesOsSecrets(options) {
+    return providerUsesExternalSecretStore(options.provider)
+        && (options.preflight.wallet.secretProviderKeyId !== null
+            || options.preflight.wallet.importedSeedSecretProviderKeyIds.length > 0);
+}
+async function collectLegacyImportedSeedSecretProviderKeyIds(stateRoot, deps = {}) {
+    const seedsRoot = join(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, deps);
+            const keyId = envelope?.secretProvider?.keyId?.trim() ?? "";
+            if (keyId.length > 0) {
+                keyIds.add(keyId);
+            }
+        }
+    }
+    return [...keyIds].sort((left, right) => left.localeCompare(right));
+}
+export async function preflightReset(options) {
+    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const removedRoots = resolveRemovedRoots(paths);
+    const rawEnvelope = await loadRawWalletStateEnvelope({
+        primaryPath: paths.walletStatePath,
+        backupPath: paths.walletStateBackupPath,
+    });
+    const snapshotPaths = resolveBootstrapPathsForTesting(options.dataDir, DEFAULT_SNAPSHOT_METADATA);
+    const validateSnapshot = options.validateSnapshotFile
+        ?? ((path) => validateSnapshotFileForTesting(path, DEFAULT_SNAPSHOT_METADATA));
+    const artifactDeps = options.artifactDeps ?? {};
+    const hasWalletState = await pathExists(paths.walletStatePath, artifactDeps)
+        || await pathExists(paths.walletStateBackupPath, artifactDeps);
+    const hasBitcoinDataDir = await pathExists(options.dataDir, artifactDeps);
+    const bitcoinDataDirWithinResetScope = hasBitcoinDataDir
+        && isDeletedByRemovalPlan(removedRoots, options.dataDir);
+    const hasSnapshot = await pathExists(snapshotPaths.snapshotPath, artifactDeps);
+    const hasPartialSnapshot = await pathExists(snapshotPaths.partialSnapshotPath, artifactDeps);
+    let snapshotStatus = "not-present";
+    if (hasSnapshot) {
+        try {
+            await validateSnapshot(snapshotPaths.snapshotPath);
+            snapshotStatus = "valid";
+        }
+        catch {
+            snapshotStatus = "invalid";
+        }
+    }
+    else if (hasPartialSnapshot) {
+        snapshotStatus = "invalid";
+    }
+    const tracked = await collectTrackedManagedProcesses(paths, options.processCleanupDeps);
+    const secretProviderKeyId = rawEnvelope?.envelope.secretProvider?.keyId ?? null;
+    const importedSeedSecretProviderKeyIds = await collectLegacyImportedSeedSecretProviderKeyIds(paths.stateRoot, artifactDeps);
+    return {
+        dataRoot: paths.dataRoot,
+        removedRoots,
+        wallet: {
+            present: hasWalletState,
+            mode: rawEnvelope == null
+                ? (hasWalletState ? "unknown" : "unknown")
+                : rawEnvelope.envelope.secretProvider != null
+                    ? "provider-backed"
+                    : "unsupported-legacy",
+            envelopeSource: rawEnvelope?.source ?? null,
+            secretProviderKeyId,
+            importedSeedSecretProviderKeyIds,
+            rawEnvelope,
+        },
+        snapshot: {
+            status: snapshotStatus,
+            path: snapshotPaths.snapshotPath,
+            shouldPrompt: snapshotStatus === "valid",
+            withinResetScope: isDeletedByRemovalPlan(removedRoots, snapshotPaths.snapshotPath),
+        },
+        bitcoinDataDir: {
+            status: !hasBitcoinDataDir
+                ? "not-present"
+                : bitcoinDataDirWithinResetScope
+                    ? "within-reset-scope"
+                    : "outside-reset-scope",
+            path: options.dataDir,
+            shouldPrompt: bitcoinDataDirWithinResetScope,
+        },
+        trackedProcesses: tracked.trackedProcesses,
+        trackedProcessKinds: tracked.trackedProcessKinds,
+        serviceLockPaths: tracked.serviceLockPaths,
+    };
+}

package/dist/wallet/reset/preview.d.ts

@@ -0,0 +1,2 @@
+import type { WalletResetPreview, WalletResetPreflightOptions } from "./types.js";
+export declare function previewResetWallet(options: WalletResetPreflightOptions): Promise<WalletResetPreview>;

package/dist/wallet/reset/preview.js

@@ -0,0 +1,50 @@
+import { createDefaultWalletSecretProvider } from "../state/provider.js";
+import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
+import { resolveRemovedRoots } from "./artifacts.js";
+import { preflightReset, resetDeletesOsSecrets } from "./preflight.js";
+export async function previewResetWallet(options) {
+    const provider = options.provider ?? createDefaultWalletSecretProvider();
+    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const preflight = await preflightReset({
+        ...options,
+        provider,
+        paths,
+    });
+    const removedPaths = resolveRemovedRoots(paths, {
+        preserveBitcoinDataDir: preflight.snapshot.status === "valid" && preflight.bitcoinDataDir.shouldPrompt,
+    });
+    return {
+        dataRoot: preflight.dataRoot,
+        confirmationPhrase: "permanently reset",
+        walletPrompt: preflight.wallet.present
+            ? {
+                defaultAction: "retain-mnemonic",
+                acceptedInputs: ["", "skip", "clear wallet entropy"],
+                entropyRetainingResetAvailable: preflight.wallet.mode === "provider-backed",
+                envelopeSource: preflight.wallet.envelopeSource,
+            }
+            : null,
+        bootstrapSnapshot: {
+            status: preflight.snapshot.status,
+            path: preflight.snapshot.path,
+            defaultAction: preflight.snapshot.status === "valid" ? "preserve" : "delete",
+        },
+        bitcoinDataDir: {
+            status: preflight.bitcoinDataDir.status,
+            path: preflight.bitcoinDataDir.path,
+            conditionalPrompt: preflight.bitcoinDataDir.shouldPrompt
+                ? {
+                    prompt: "Delete managed Bitcoin datadir too? [y/N]: ",
+                    defaultAction: "preserve",
+                    acceptedInputs: ["", "n", "no", "y", "yes"],
+                }
+                : null,
+        },
+        trackedProcessKinds: preflight.trackedProcessKinds,
+        willDeleteOsSecrets: resetDeletesOsSecrets({
+            provider,
+            preflight,
+        }),
+        removedPaths,
+    };
+}

package/dist/wallet/reset/process-cleanup.d.ts

@@ -0,0 +1,12 @@
+import { type FileLockHandle } from "../fs/lock.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { TrackedManagedProcess, WalletResetProcessCleanupDependencies, WalletResetResult } from "./types.js";
+export declare function isProcessAlive(pid: number | null, deps?: WalletResetProcessCleanupDependencies): Promise<boolean>;
+export declare function waitForProcessExit(pid: number, timeoutMs?: number, deps?: WalletResetProcessCleanupDependencies): Promise<boolean>;
+export declare function terminateTrackedProcesses(trackedProcesses: readonly TrackedManagedProcess[], deps?: WalletResetProcessCleanupDependencies): Promise<WalletResetResult["stoppedProcesses"]>;
+export declare function collectTrackedManagedProcesses(paths: WalletRuntimePaths, deps?: WalletResetProcessCleanupDependencies): Promise<{
+    trackedProcesses: TrackedManagedProcess[];
+    trackedProcessKinds: Array<TrackedManagedProcess["kind"]>;
+    serviceLockPaths: string[];
+}>;
+export declare function acquireResetLocks(paths: WalletRuntimePaths, serviceLockPaths: readonly string[], deps?: WalletResetProcessCleanupDependencies): Promise<FileLockHandle[]>;

package/dist/wallet/reset/process-cleanup.js

@@ -0,0 +1,179 @@
+import { loadMiningRuntimeStatus } from "../mining/runtime-artifacts.js";
+import { acquireFileLock } from "../fs/lock.js";
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+import { readJsonFileOrNull } from "./artifacts.js";
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function resolveProcessCleanupDependencies(overrides = {}) {
+    return {
+        acquireLock: overrides.acquireLock ?? acquireFileLock,
+        processKill: overrides.processKill ?? process.kill.bind(process),
+        sleep: overrides.sleep ?? sleep,
+    };
+}
+export async function isProcessAlive(pid, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    if (pid === null) {
+        return false;
+    }
+    try {
+        resolved.processKill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+            return false;
+        }
+        return true;
+    }
+}
+export async function waitForProcessExit(pid, timeoutMs = 15_000, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!await isProcessAlive(pid, resolved)) {
+            return true;
+        }
+        await resolved.sleep(100);
+    }
+    return !await isProcessAlive(pid, resolved);
+}
+export async function terminateTrackedProcesses(trackedProcesses, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const survivors = new Set();
+    for (const processInfo of trackedProcesses) {
+        try {
+            resolved.processKill(processInfo.pid, "SIGTERM");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                throw error;
+            }
+        }
+    }
+    for (const processInfo of trackedProcesses) {
+        if (!await waitForProcessExit(processInfo.pid, 5_000, resolved)) {
+            survivors.add(processInfo.pid);
+        }
+    }
+    for (const pid of survivors) {
+        try {
+            resolved.processKill(pid, "SIGKILL");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                throw error;
+            }
+        }
+    }
+    const remaining = new Set();
+    for (const pid of survivors) {
+        if (!await waitForProcessExit(pid, 5_000, resolved)) {
+            remaining.add(pid);
+        }
+    }
+    if (remaining.size > 0) {
+        throw new Error("reset_process_shutdown_failed");
+    }
+    return {
+        managedBitcoind: trackedProcesses.filter((processInfo) => processInfo.kind === "managed-bitcoind").length,
+        indexerDaemon: trackedProcesses.filter((processInfo) => processInfo.kind === "indexer-daemon").length,
+        backgroundMining: trackedProcesses.filter((processInfo) => processInfo.kind === "background-mining").length,
+        survivors: 0,
+    };
+}
+export async function collectTrackedManagedProcesses(paths, deps = {}) {
+    const trackedProcesses = [];
+    const trackedProcessKinds = new Set();
+    const serviceLockPaths = new Set();
+    const runtimeEntries = await readdir(paths.runtimeRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of runtimeEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const serviceRoot = join(paths.runtimeRoot, entry.name);
+        const bitcoindStatus = await readJsonFileOrNull(join(serviceRoot, "bitcoind-status.json"));
+        if (bitcoindStatus?.processId != null && await isProcessAlive(bitcoindStatus.processId, deps)) {
+            trackedProcesses.push({
+                kind: "managed-bitcoind",
+                pid: bitcoindStatus.processId,
+            });
+            trackedProcessKinds.add("managed-bitcoind");
+            serviceLockPaths.add(join(serviceRoot, "bitcoind.lock"));
+        }
+    }
+    const indexerEntries = await readdir(paths.indexerRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of indexerEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const status = await readJsonFileOrNull(join(paths.indexerRoot, entry.name, "status.json"));
+        if (status?.processId != null && await isProcessAlive(status.processId, deps)) {
+            trackedProcesses.push({
+                kind: "indexer-daemon",
+                pid: status.processId,
+            });
+            trackedProcessKinds.add("indexer-daemon");
+            serviceLockPaths.add(join(paths.runtimeRoot, entry.name, "indexer-daemon.lock"));
+        }
+    }
+    const miningRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
+    if (miningRuntime?.backgroundWorkerPid != null
+        && await isProcessAlive(miningRuntime.backgroundWorkerPid, deps)) {
+        trackedProcesses.push({
+            kind: "background-mining",
+            pid: miningRuntime.backgroundWorkerPid,
+        });
+        trackedProcessKinds.add("background-mining");
+    }
+    const seen = new Set();
+    const deduped = trackedProcesses.filter((processInfo) => {
+        const key = `${processInfo.kind}:${processInfo.pid}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    return {
+        trackedProcesses: deduped,
+        trackedProcessKinds: [...trackedProcessKinds],
+        serviceLockPaths: [...serviceLockPaths].sort(),
+    };
+}
+export async function acquireResetLocks(paths, serviceLockPaths, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const lockPaths = [
+        paths.walletControlLockPath,
+        paths.miningControlLockPath,
+        ...serviceLockPaths,
+    ];
+    const handles = [];
+    try {
+        for (const lockPath of lockPaths) {
+            handles.push(await resolved.acquireLock(lockPath, {
+                purpose: "wallet-reset",
+                walletRootId: null,
+            }));
+        }
+        return handles;
+    }
+    catch (error) {
+        await Promise.all(handles.map(async (handle) => handle.release().catch(() => undefined)));
+        throw error;
+    }
+}

package/dist/wallet/reset/types.d.ts

@@ -0,0 +1,189 @@
+import { type FileLockHandle } from "../fs/lock.js";
+import type { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import type { createRpcClient } from "../../bitcoind/node.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { WalletSecretProvider } from "../state/provider.js";
+import type { RawWalletStateEnvelope } from "../state/storage.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletPrompter } from "../lifecycle.js";
+export type WalletResetAction = "not-present" | "kept-unchanged" | "retain-mnemonic" | "deleted";
+export type WalletResetSecretCleanupStatus = "deleted" | "not-found" | "failed" | "unknown";
+export type WalletResetSnapshotResultStatus = "not-present" | "invalid-removed" | "deleted" | "preserved";
+export type WalletResetBitcoinDataDirResultStatus = "not-present" | "preserved" | "deleted" | "outside-reset-scope";
+export interface WalletResetResult {
+    dataRoot: string;
+    factoryResetReady: true;
+    stoppedProcesses: {
+        managedBitcoind: number;
+        indexerDaemon: number;
+        backgroundMining: number;
+        survivors: number;
+    };
+    secretCleanupStatus: WalletResetSecretCleanupStatus;
+    deletedSecretRefs: string[];
+    failedSecretRefs: string[];
+    preservedSecretRefs: string[];
+    walletAction: WalletResetAction;
+    walletOldRootId: string | null;
+    walletNewRootId: string | null;
+    bootstrapSnapshot: {
+        status: WalletResetSnapshotResultStatus;
+        path: string;
+    };
+    bitcoinDataDir: {
+        status: WalletResetBitcoinDataDirResultStatus;
+        path: string;
+    };
+    removedPaths: string[];
+}
+export interface WalletResetPreview {
+    dataRoot: string;
+    confirmationPhrase: "permanently reset";
+    walletPrompt: null | {
+        defaultAction: "retain-mnemonic";
+        acceptedInputs: ["", "skip", "clear wallet entropy"];
+        entropyRetainingResetAvailable: boolean;
+        envelopeSource: "primary" | "backup" | null;
+    };
+    bootstrapSnapshot: {
+        status: "not-present" | "invalid" | "valid";
+        path: string;
+        defaultAction: "preserve" | "delete";
+    };
+    bitcoinDataDir: {
+        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
+        path: string;
+        conditionalPrompt: null | {
+            prompt: "Delete managed Bitcoin datadir too? [y/N]: ";
+            defaultAction: "preserve";
+            acceptedInputs: ["", "n", "no", "y", "yes"];
+        };
+    };
+    trackedProcessKinds: Array<"managed-bitcoind" | "indexer-daemon" | "background-mining">;
+    willDeleteOsSecrets: boolean;
+    removedPaths: string[];
+}
+export type WalletEnvelopeMode = "provider-backed" | "unsupported-legacy" | "unknown";
+export interface WalletResetPreflight {
+    dataRoot: string;
+    removedRoots: string[];
+    wallet: {
+        present: boolean;
+        mode: WalletEnvelopeMode;
+        envelopeSource: "primary" | "backup" | null;
+        secretProviderKeyId: string | null;
+        importedSeedSecretProviderKeyIds: string[];
+        rawEnvelope: RawWalletStateEnvelope | null;
+    };
+    snapshot: {
+        status: "not-present" | "invalid" | "valid";
+        path: string;
+        shouldPrompt: boolean;
+        withinResetScope: boolean;
+    };
+    bitcoinDataDir: {
+        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
+        path: string;
+        shouldPrompt: boolean;
+    };
+    trackedProcesses: TrackedManagedProcess[];
+    trackedProcessKinds: Array<TrackedManagedProcess["kind"]>;
+    serviceLockPaths: string[];
+}
+export interface TrackedManagedProcess {
+    kind: "managed-bitcoind" | "indexer-daemon" | "background-mining";
+    pid: number;
+}
+export interface StagedArtifact {
+    originalPath: string;
+    stagedPath: string;
+    restorePath: string;
+}
+export interface WalletAccessForReset {
+    loaded: {
+        source: "primary" | "backup";
+        state: WalletStateV1;
+    };
+    access: {
+        kind: "provider";
+        provider: WalletSecretProvider;
+    };
+}
+export interface ResetWalletRpcClient {
+    getDescriptorInfo(descriptor: string): Promise<{
+        descriptor: string;
+        checksum: string;
+    }>;
+    createWallet(walletName: string, options: {
+        blank: boolean;
+        descriptors: boolean;
+        disablePrivateKeys: boolean;
+        loadOnStartup: boolean;
+        passphrase: string;
+    }): Promise<unknown>;
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
+    importDescriptors(walletName: string, requests: Array<{
+        desc: string;
+        timestamp: string | number;
+        active?: boolean;
+        internal?: boolean;
+        range?: number | [number, number];
+    }>): Promise<Array<{
+        success: boolean;
+    }>>;
+    walletLock(walletName: string): Promise<null>;
+    deriveAddresses(descriptor: string, range?: number | [number, number]): Promise<string[]>;
+    listDescriptors(walletName: string, privateOnly?: boolean): Promise<{
+        descriptors: Array<{
+            desc: string;
+        }>;
+    }>;
+    getWalletInfo(walletName: string): Promise<{
+        walletname: string;
+        private_keys_enabled: boolean;
+        descriptors: boolean;
+    }>;
+    loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
+        name: string;
+        warning: string;
+    }>;
+    listWallets(): Promise<string[]>;
+}
+export interface ResetExecutionDecision {
+    walletChoice: "" | "skip" | "clear wallet entropy";
+    deleteSnapshot: boolean;
+    deleteBitcoinDataDir: boolean;
+    loadedWalletForEntropyReset: WalletAccessForReset | null;
+}
+export interface WalletResetArtifactDependencies {
+    access?: typeof import("node:fs/promises").access;
+    copyFile?: typeof import("node:fs/promises").copyFile;
+    mkdir?: typeof import("node:fs/promises").mkdir;
+    readFile?: typeof import("node:fs/promises").readFile;
+    rename?: typeof import("node:fs/promises").rename;
+    remove?: typeof import("node:fs/promises").rm;
+}
+export interface WalletResetProcessCleanupDependencies {
+    acquireLock?: (path: string, metadata: {
+        purpose: string;
+        walletRootId: null;
+    }) => Promise<FileLockHandle>;
+    processKill?: typeof process.kill;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface WalletResetBaseOptions {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    paths?: WalletRuntimePaths;
+}
+export interface WalletResetPreflightOptions extends WalletResetBaseOptions {
+    validateSnapshotFile?: (path: string) => Promise<void>;
+    artifactDeps?: WalletResetArtifactDependencies;
+    processCleanupDeps?: WalletResetProcessCleanupDependencies;
+}
+export interface WalletResetExecutionOptions extends WalletResetPreflightOptions {
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => ResetWalletRpcClient;
+}

package/dist/wallet/reset/types.js

@@ -0,0 +1 @@
+import {} from "../fs/lock.js";

package/dist/wallet/reset.d.ts

@@ -1,119 +1,4 @@
-import { createRpcClient } from "../bitcoind/node.js";
-import { attachOrStartManagedBitcoindService } from "../bitcoind/service.js";
-import { type WalletRuntimePaths } from "./runtime.js";
-import { type WalletSecretProvider } from "./state/provider.js";
-import type { WalletPrompter } from "./lifecycle.js";
-export type WalletResetAction = "not-present" | "kept-unchanged" | "retain-mnemonic" | "deleted";
-export type WalletResetSecretCleanupStatus = "deleted" | "not-found" | "failed" | "unknown";
-export type WalletResetSnapshotResultStatus = "not-present" | "invalid-removed" | "deleted" | "preserved";
-export type WalletResetBitcoinDataDirResultStatus = "not-present" | "preserved" | "deleted" | "outside-reset-scope";
-export interface WalletResetResult {
-    dataRoot: string;
-    factoryResetReady: true;
-    stoppedProcesses: {
-        managedBitcoind: number;
-        indexerDaemon: number;
-        backgroundMining: number;
-        survivors: number;
-    };
-    secretCleanupStatus: WalletResetSecretCleanupStatus;
-    deletedSecretRefs: string[];
-    failedSecretRefs: string[];
-    preservedSecretRefs: string[];
-    walletAction: WalletResetAction;
-    walletOldRootId: string | null;
-    walletNewRootId: string | null;
-    bootstrapSnapshot: {
-        status: WalletResetSnapshotResultStatus;
-        path: string;
-    };
-    bitcoinDataDir: {
-        status: WalletResetBitcoinDataDirResultStatus;
-        path: string;
-    };
-    removedPaths: string[];
-}
-export interface WalletResetPreview {
-    dataRoot: string;
-    confirmationPhrase: "permanently reset";
-    walletPrompt: null | {
-        defaultAction: "retain-mnemonic";
-        acceptedInputs: ["", "skip", "clear wallet entropy"];
-        entropyRetainingResetAvailable: boolean;
-        envelopeSource: "primary" | "backup" | null;
-    };
-    bootstrapSnapshot: {
-        status: "not-present" | "invalid" | "valid";
-        path: string;
-        defaultAction: "preserve" | "delete";
-    };
-    bitcoinDataDir: {
-        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
-        path: string;
-        conditionalPrompt: null | {
-            prompt: "Delete managed Bitcoin datadir too? [y/N]: ";
-            defaultAction: "preserve";
-            acceptedInputs: ["", "n", "no", "y", "yes"];
-        };
-    };
-    trackedProcessKinds: Array<"managed-bitcoind" | "indexer-daemon" | "background-mining">;
-    willDeleteOsSecrets: boolean;
-    removedPaths: string[];
-}
-interface ResetWalletRpcClient {
-    getDescriptorInfo(descriptor: string): Promise<{
-        descriptor: string;
-        checksum: string;
-    }>;
-    createWallet(walletName: string, options: {
-        blank: boolean;
-        descriptors: boolean;
-        disablePrivateKeys: boolean;
-        loadOnStartup: boolean;
-        passphrase: string;
-    }): Promise<unknown>;
-    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
-    importDescriptors(walletName: string, requests: Array<{
-        desc: string;
-        timestamp: string | number;
-        active?: boolean;
-        internal?: boolean;
-        range?: number | [number, number];
-    }>): Promise<Array<{
-        success: boolean;
-    }>>;
-    walletLock(walletName: string): Promise<null>;
-    deriveAddresses(descriptor: string, range?: number | [number, number]): Promise<string[]>;
-    listDescriptors(walletName: string, privateOnly?: boolean): Promise<{
-        descriptors: Array<{
-            desc: string;
-        }>;
-    }>;
-    getWalletInfo(walletName: string): Promise<{
-        walletname: string;
-        private_keys_enabled: boolean;
-        descriptors: boolean;
-    }>;
-    loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
-        name: string;
-        warning: string;
-    }>;
-    listWallets(): Promise<string[]>;
-}
-export declare function previewResetWallet(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    paths?: WalletRuntimePaths;
-    validateSnapshotFile?: (path: string) => Promise<void>;
-}): Promise<WalletResetPreview>;
-export declare function resetWallet(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    validateSnapshotFile?: (path: string) => Promise<void>;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => ResetWalletRpcClient;
-}): Promise<WalletResetResult>;
-export {};
+export type { WalletResetAction, WalletResetBitcoinDataDirResultStatus, WalletResetPreview, WalletResetResult, WalletResetSecretCleanupStatus, WalletResetSnapshotResultStatus, } from "./reset/types.js";
+import type { WalletResetExecutionOptions, WalletResetPreflightOptions, WalletResetPreview, WalletResetResult } from "./reset/types.js";
+export declare function previewResetWallet(options: WalletResetPreflightOptions): Promise<WalletResetPreview>;
+export declare function resetWallet(options: WalletResetExecutionOptions): Promise<WalletResetResult>;