@cogcoin/client 1.1.7 → 1.1.9

package/dist/cli/wallet-read-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { WalletFieldView, WalletLockView, WalletReadContext } from "../wallet/read/index.js";
+export declare function listVisibleWalletLocks(context: WalletReadContext, options: {
+    claimableOnly: boolean;
+    reclaimableOnly: boolean;
+}): WalletLockView[] | null;
+export declare function listVisibleDomainFields(context: WalletReadContext, domainName: string): WalletFieldView[] | null;

package/dist/cli/wallet-read-helpers.js

@@ -0,0 +1,17 @@
+import { listDomainFields, listWalletLocks, } from "../wallet/read/index.js";
+export function listVisibleWalletLocks(context, options) {
+    const locks = listWalletLocks(context);
+    if (locks === null) {
+        return null;
+    }
+    if (options.claimableOnly) {
+        return locks.filter((lock) => lock.claimableNow);
+    }
+    if (options.reclaimableOnly) {
+        return locks.filter((lock) => lock.reclaimableNow);
+    }
+    return locks;
+}
+export function listVisibleDomainFields(context, domainName) {
+    return listDomainFields(context, domainName);
+}

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

@@ -45,7 +45,7 @@ export declare function buildMiningGenerationRequest(options: {
         requiredWords: [string, string, string, string, string];
     }>;
     domainExtraPrompts: Record<string, string>;
-    extraPrompt: string | null;
+    fallbackInstruction: string | null;
 }): MiningSentenceGenerationRequest;
 export declare function generateCandidatesForDomains(options: {
     rpc: MiningRpcClient;

package/dist/wallet/mining/candidate.js

@@ -114,13 +114,13 @@ export function buildMiningGenerationRequest(options) {
         targetBlockHeight: options.targetBlockHeight,
         referencedBlockHashDisplay: options.referencedBlockHashDisplay,
         generatedAtUnixMs: options.generatedAtUnixMs ?? Date.now(),
-        extraPrompt: options.extraPrompt,
+        fallbackInstruction: options.fallbackInstruction,
         limits: createMiningSentenceRequestLimits(),
         rootDomains: options.domains.map((domain) => ({
             domainId: domain.domainId,
             domainName: domain.domainName,
             requiredWords: domain.requiredWords,
-            extraPrompt: options.domainExtraPrompts[domain.domainName.toLowerCase()] ?? null,
+            domainInstruction: options.domainExtraPrompts[domain.domainName.toLowerCase()] ?? null,
         })),
     };
 }
@@ -193,7 +193,7 @@ export async function generateCandidatesForDomains(options) {
             referencedBlockHashDisplay: bestBlockHash,
             domains: rootDomains,
             domainExtraPrompts: clientConfig?.mining.domainExtraPrompts ?? {},
-            extraPrompt: clientConfig?.mining.builtIn?.extraPrompt ?? null,
+            fallbackInstruction: clientConfig?.mining.builtIn?.extraPrompt ?? null,
         });
         let generated;
         try {

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

@@ -10,8 +10,8 @@ export declare const MINING_LOOP_INTERVAL_MS = 2000;
 export declare const MINING_BUILTIN_TIMEOUT_MS = 30000;
 export declare const MINING_SENTENCE_SCHEMA_VERSION: 1;
 export declare const MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
-export declare const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
-export declare const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 64;
+export declare const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 25;
+export declare const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 500;
 export declare const MINING_SENTENCE_TIMEOUT_MS = 30000;
 export declare const MINING_SHUTDOWN_GRACE_MS = 15000;
 export declare const MINING_SETTLEMENT_DUMMY_REWARD = 100n;

package/dist/wallet/mining/constants.js

@@ -10,8 +10,8 @@ export const MINING_LOOP_INTERVAL_MS = 2_000;
 export const MINING_BUILTIN_TIMEOUT_MS = 30_000;
 export const MINING_SENTENCE_SCHEMA_VERSION = 1;
 export const MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
-export const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
-export const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 64;
+export const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 25;
+export const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 500;
 export const MINING_SENTENCE_TIMEOUT_MS = 30_000;
 export const MINING_SHUTDOWN_GRACE_MS = 15_000;
 export const MINING_SETTLEMENT_DUMMY_REWARD = 100n;

package/dist/wallet/mining/engine-state.js

@@ -135,13 +135,23 @@ export function buildMiningTipKey(bestBlockHash, targetBlockHeight) {
     }
     return `${bestBlockHash}:${targetBlockHeight}`;
 }
+function cloneSettledBoardEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        requiredWords: [...entry.requiredWords],
+    }));
+}
 export function resetMiningUiForTip(loopState, _targetBlockHeight) {
     const preservedTxid = loopState.ui.latestTxid;
     const preservedFundingAddress = loopState.ui.fundingAddress;
+    const preservedSettledBlockHeight = loopState.ui.settledBlockHeight;
+    const preservedSettledBoardEntries = cloneSettledBoardEntries(loopState.ui.settledBoardEntries);
     loopState.ui = {
         ...createEmptyMiningFollowVisualizerState(),
         fundingAddress: preservedFundingAddress,
         latestTxid: preservedTxid,
+        settledBlockHeight: preservedSettledBlockHeight,
+        settledBoardEntries: preservedSettledBoardEntries,
     };
     loopState.selectedCandidateTipKey = null;
     loopState.selectedCandidate = null;

package/dist/wallet/mining/sentence-protocol.d.ts

@@ -5,7 +5,7 @@ export interface MiningSentenceGenerationRequestV1 {
     targetBlockHeight: number;
     referencedBlockHashDisplay: string;
     generatedAtUnixMs: number;
-    extraPrompt: string | null;
+    fallbackInstruction: string | null;
     limits: {
         maxCandidatesPerRootDomain: number;
         maxCandidatesTotal: number;
@@ -16,7 +16,7 @@ export interface MiningSentenceGenerationRequestV1 {
         domainId: number;
         domainName: string;
         requiredWords: [string, string, string, string, string];
-        extraPrompt: string | null;
+        domainInstruction: string | null;
     }>;
 }
 export interface MiningSentenceCandidateV1 {

package/dist/wallet/mining/sentences.js

@@ -26,20 +26,20 @@ function createBuiltInProviderTimeoutError(options) {
     const unit = seconds === "1" ? "second" : "seconds";
     return new MiningProviderRequestError("unavailable", `The built-in ${providerName} mining provider timed out after ${seconds} ${unit}.`);
 }
-function buildSystemPrompt(extraPrompt) {
+function buildSystemPrompt(fallbackInstruction) {
     const lines = [
         "You are helping generate candidate Cogcoin mining sentences.",
         "Return only JSON matching the requested response schema.",
         "Every sentence must be a single natural-language sentence.",
         "Do not add commentary, markdown, or code fences.",
         "Do not invent domain IDs or request IDs.",
-        "Each rootDomains entry may include an extraPrompt that applies only to that domain.",
-        "If rootDomains[i].extraPrompt is present, use it only for candidates for that domainId.",
-        "If rootDomains[i].extraPrompt is null, fall back to the request-level extraPrompt when it is present.",
+        "Each rootDomains entry may include a domainInstruction that applies only to that domain.",
+        "If rootDomains[i].domainInstruction is present, use it only for candidates for that domainId.",
+        "If rootDomains[i].domainInstruction is null, fall back to the request-level fallbackInstruction when it is present.",
         "Never apply one domain's prompt to another domain's candidates.",
     ];
-    if (extraPrompt !== null && extraPrompt.trim().length > 0) {
-        lines.push(`Request-level fallback instruction: ${extraPrompt.trim()}`);
+    if (fallbackInstruction !== null && fallbackInstruction.trim().length > 0) {
+        lines.push(`Request-level fallback instruction: ${fallbackInstruction.trim()}`);
     }
     return lines.join("\n");
 }
@@ -162,7 +162,7 @@ async function requestBuiltInSentences(options) {
                     input: [
                         {
                             role: "system",
-                            content: buildSystemPrompt(options.request.extraPrompt),
+                            content: buildSystemPrompt(options.request.fallbackInstruction),
                         },
                         {
                             role: "user",
@@ -209,7 +209,7 @@ async function requestBuiltInSentences(options) {
             body: JSON.stringify({
                 model,
                 max_tokens: 1_200,
-                system: buildSystemPrompt(options.request.extraPrompt),
+                system: buildSystemPrompt(options.request.fallbackInstruction),
                 messages: [
                     {
                         role: "user",

package/dist/wallet/mining/visualizer-sync.js

@@ -4,6 +4,12 @@ import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-
 import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
 import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
+function cloneSettledBoardEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        requiredWords: [...entry.requiredWords],
+    }));
+}
 function resolveSettledWinnerRequiredWords(options) {
     const storedWords = resolveBip39WordsFromIndices(options.bip39WordIndices);
     if (storedWords.length > 0) {
@@ -20,6 +26,46 @@ function resolveSettledWinnerRequiredWords(options) {
 function fallbackSettledWinnerDomainName(domainId) {
     return `domain-${domainId}`;
 }
+function resolveSettledBoardEntriesForHeight(options) {
+    if (options.snapshotState === null || options.snapshotState === undefined) {
+        return null;
+    }
+    const winners = getBlockWinners(options.snapshotState, options.blockHeight);
+    if (winners === null) {
+        return null;
+    }
+    const snapshotState = options.snapshotState;
+    return winners
+        .slice()
+        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
+        .slice(0, 5)
+        .map((winner) => ({
+        rank: winner.rank,
+        domainName: lookupDomainById(snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
+        sentence: winner.sentenceText ?? "[unavailable]",
+        requiredWords: resolveSettledWinnerRequiredWords({
+            domainId: winner.domainId,
+            bip39WordIndices: winner.bip39WordIndices,
+            snapshotTipPreviousHashHex: options.blockPreviousHashHex,
+        }),
+    }));
+}
+function resolveLatestPriorNonEmptySettledBoard(options) {
+    for (let blockHeight = options.snapshotTipHeight - 1; blockHeight >= 0; blockHeight -= 1) {
+        const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+            snapshotState: options.snapshotState,
+            blockHeight,
+            blockPreviousHashHex: null,
+        });
+        if (settledBoardEntries !== null && settledBoardEntries.length > 0) {
+            return {
+                settledBlockHeight: blockHeight,
+                settledBoardEntries,
+            };
+        }
+    }
+    return null;
+}
 function resolveCurrentMinedBlockBoard(options) {
     const settledBlockHeight = options.snapshotTipHeight ?? null;
     if (settledBlockHeight === null) {
@@ -34,23 +80,37 @@ function resolveCurrentMinedBlockBoard(options) {
             settledBoardEntries: [],
         };
     }
-    const settledBoardEntries = (getBlockWinners(options.snapshotState, settledBlockHeight) ?? [])
-        .slice()
-        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
-        .slice(0, 5)
-        .map((winner) => ({
-        rank: winner.rank,
-        domainName: lookupDomainById(options.snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
-        sentence: winner.sentenceText ?? "[unavailable]",
-        requiredWords: resolveSettledWinnerRequiredWords({
-            domainId: winner.domainId,
-            bip39WordIndices: winner.bip39WordIndices,
-            snapshotTipPreviousHashHex: options.snapshotTipPreviousHashHex,
-        }),
-    }));
+    const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+        snapshotState: options.snapshotState,
+        blockHeight: settledBlockHeight,
+        blockPreviousHashHex: options.snapshotTipPreviousHashHex,
+    });
+    if (settledBoardEntries !== null) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries,
+        };
+    }
+    const currentDisplayedBlockHeight = options.currentDisplayedBoard?.settledBlockHeight ?? null;
+    const currentDisplayedEntries = options.currentDisplayedBoard?.settledBoardEntries ?? [];
+    if (currentDisplayedBlockHeight !== null
+        && currentDisplayedBlockHeight <= settledBlockHeight
+        && currentDisplayedEntries.length > 0) {
+        return {
+            settledBlockHeight: currentDisplayedBlockHeight,
+            settledBoardEntries: cloneSettledBoardEntries(currentDisplayedEntries),
+        };
+    }
+    const latestPriorNonEmptyBoard = resolveLatestPriorNonEmptySettledBoard({
+        snapshotState: options.snapshotState,
+        snapshotTipHeight: settledBlockHeight,
+    });
+    if (latestPriorNonEmptyBoard !== null) {
+        return latestPriorNonEmptyBoard;
+    }
     return {
         settledBlockHeight,
-        settledBoardEntries,
+        settledBoardEntries: [],
     };
 }
 export function resolveSettledBoard(options) {
@@ -66,6 +126,10 @@ function syncMiningUiSettledBoard(loopState, snapshotState, snapshotTipHeight, s
         snapshotState,
         snapshotTipHeight,
         snapshotTipPreviousHashHex,
+        currentDisplayedBoard: {
+            settledBlockHeight: loopState.ui.settledBlockHeight,
+            settledBoardEntries: loopState.ui.settledBoardEntries,
+        },
     });
     loopState.ui.settledBlockHeight = settledBoard.settledBlockHeight;
     loopState.ui.settledBoardEntries = settledBoard.settledBoardEntries;

package/dist/wallet/read/context.js

@@ -16,7 +16,7 @@ import { createDefaultWalletSecretProvider, createWalletSecretReference, inspect
 import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.js";
 import { openManagedWalletReadServiceBundle } from "./managed-services.js";
 import { createWalletReadModel } from "./project.js";
-const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
+const DEFAULT_SERVICE_START_TIMEOUT_MS = 60_000;
 function btcAmountToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }

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

@@ -0,0 +1,16 @@
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { StagedArtifact, WalletResetArtifactDependencies } from "./types.js";
+export declare function pathExists(path: string, deps?: WalletResetArtifactDependencies): Promise<boolean>;
+export declare function readJsonFileOrNull<T>(path: string, deps?: WalletResetArtifactDependencies): Promise<T | null>;
+export declare function isPathWithin(root: string, target: string): boolean;
+export declare function dedupeSortedPaths(candidates: readonly string[]): string[];
+export declare function resolveDefaultRemovedRoots(paths: WalletRuntimePaths): string[];
+export declare function resolveBitcoindPreservingRemovedRoots(paths: WalletRuntimePaths): string[];
+export declare function resolveRemovedRoots(paths: WalletRuntimePaths, options?: {
+    preserveBitcoinDataDir: boolean;
+}): string[];
+export declare function isDeletedByRemovalPlan(removedRoots: readonly string[], targetPath: string): boolean;
+export declare function stageArtifact(sourcePath: string, stagingRoot: string, label: string, deps?: WalletResetArtifactDependencies): Promise<StagedArtifact | null>;
+export declare function restoreStagedArtifacts(artifacts: readonly StagedArtifact[], deps?: WalletResetArtifactDependencies): Promise<void>;
+export declare function deleteRemovedRoots(roots: readonly string[], deps?: WalletResetArtifactDependencies): Promise<void>;
+export declare function deleteBootstrapSnapshotArtifacts(dataDir: string, deps?: WalletResetArtifactDependencies): Promise<void>;

package/dist/wallet/reset/artifacts.js

@@ -0,0 +1,141 @@
+import { access, constants, copyFile, mkdir, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { DEFAULT_SNAPSHOT_METADATA } from "../../bitcoind/bootstrap/constants.js";
+import { resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap/paths.js";
+import { resolveLegacyHooksRootPath } from "../../app-paths.js";
+function resolveArtifactDependencies(overrides = {}) {
+    return {
+        access: overrides.access ?? access,
+        copyFile: overrides.copyFile ?? copyFile,
+        mkdir: overrides.mkdir ?? mkdir,
+        readFile: overrides.readFile ?? readFile,
+        rename: overrides.rename ?? rename,
+        remove: overrides.remove ?? rm,
+    };
+}
+export async function pathExists(path, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        await resolved.access(path, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function readJsonFileOrNull(path, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        return JSON.parse(await resolved.readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+export function isPathWithin(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && rel !== ".");
+}
+export function dedupeSortedPaths(candidates) {
+    return [...new Set(candidates)].sort((left, right) => right.length - left.length);
+}
+export function resolveDefaultRemovedRoots(paths) {
+    const configRoot = dirname(paths.clientConfigPath);
+    return dedupeSortedPaths([
+        paths.dataRoot,
+        paths.stateRoot,
+        paths.runtimeRoot,
+        configRoot,
+    ]);
+}
+export function resolveBitcoindPreservingRemovedRoots(paths) {
+    const configRoot = dirname(paths.clientConfigPath);
+    return dedupeSortedPaths([
+        paths.clientDataDir,
+        paths.indexerRoot,
+        paths.stateRoot,
+        paths.runtimeRoot,
+        configRoot,
+        resolveLegacyHooksRootPath({
+            dataRoot: paths.dataRoot,
+            clientConfigPath: paths.clientConfigPath,
+        }),
+    ]);
+}
+export function resolveRemovedRoots(paths, options = {
+    preserveBitcoinDataDir: false,
+}) {
+    return options.preserveBitcoinDataDir
+        ? resolveBitcoindPreservingRemovedRoots(paths)
+        : resolveDefaultRemovedRoots(paths);
+}
+export function isDeletedByRemovalPlan(removedRoots, targetPath) {
+    return removedRoots.some((root) => isPathWithin(root, targetPath));
+}
+async function moveFile(sourcePath, destinationPath, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    await resolved.mkdir(dirname(destinationPath), { recursive: true });
+    try {
+        await resolved.rename(sourcePath, destinationPath);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "EXDEV") {
+            throw error;
+        }
+        await resolved.copyFile(sourcePath, destinationPath);
+        await resolved.remove(sourcePath, { force: true });
+    }
+}
+export async function stageArtifact(sourcePath, stagingRoot, label, deps = {}) {
+    if (!await pathExists(sourcePath, deps)) {
+        return null;
+    }
+    const stagedPath = join(stagingRoot, label);
+    await moveFile(sourcePath, stagedPath, deps);
+    return {
+        originalPath: sourcePath,
+        stagedPath,
+        restorePath: sourcePath,
+    };
+}
+export async function restoreStagedArtifacts(artifacts, deps = {}) {
+    for (const artifact of artifacts) {
+        if (!await pathExists(artifact.stagedPath, deps)) {
+            continue;
+        }
+        await moveFile(artifact.stagedPath, artifact.restorePath, deps);
+    }
+}
+export async function deleteRemovedRoots(roots, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        for (const root of roots) {
+            await resolved.remove(root, {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+    catch {
+        throw new Error("reset_data_root_delete_failed");
+    }
+}
+export async function deleteBootstrapSnapshotArtifacts(dataDir, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    const snapshotPaths = resolveBootstrapPathsForTesting(dataDir, DEFAULT_SNAPSHOT_METADATA);
+    await Promise.all([
+        snapshotPaths.snapshotPath,
+        snapshotPaths.partialSnapshotPath,
+        snapshotPaths.statePath,
+        snapshotPaths.quoteStatePath,
+    ].map(async (path) => resolved.remove(path, {
+        recursive: false,
+        force: true,
+    })));
+}

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

@@ -0,0 +1,38 @@
+import { type WalletRuntimePaths } from "../runtime.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import { type WalletStateSaveAccess } from "../state/storage.js";
+import type { WalletStateV1 } from "../types.js";
+import { preflightReset } from "./preflight.js";
+import type { ResetExecutionDecision, WalletAccessForReset, WalletResetAction, WalletResetBitcoinDataDirResultStatus, WalletResetExecutionOptions, WalletResetPreflight, WalletResetResult, WalletResetSnapshotResultStatus } from "./types.js";
+export declare function loadWalletForEntropyReset(options: {
+    wallet: WalletResetPreflight["wallet"];
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+}): Promise<WalletAccessForReset>;
+export declare function createEntropyRetainedWalletState(previousState: WalletStateV1, nowUnixMs: number): WalletStateV1;
+export declare function recreateManagedCoreWalletReplicaForReset(options: {
+    state: WalletStateV1;
+    access: WalletStateSaveAccess;
+    paths: NonNullable<WalletResetExecutionOptions["paths"]>;
+    dataDir: string;
+    nowUnixMs: number;
+    attachService?: WalletResetExecutionOptions["attachService"];
+    rpcFactory?: WalletResetExecutionOptions["rpcFactory"];
+}): Promise<WalletStateV1>;
+export declare function resolveResetExecutionDecision(options: {
+    preflight: Awaited<ReturnType<typeof preflightReset>>;
+    provider: NonNullable<WalletResetExecutionOptions["provider"]>;
+    prompter: WalletResetExecutionOptions["prompter"];
+    paths: NonNullable<WalletResetExecutionOptions["paths"]>;
+}): Promise<ResetExecutionDecision>;
+export declare function determineWalletAction(walletPresent: boolean, walletChoice: ResetExecutionDecision["walletChoice"]): WalletResetAction;
+export declare function determineSnapshotResultStatus(options: {
+    snapshotStatus: Awaited<ReturnType<typeof preflightReset>>["snapshot"]["status"];
+    deleteSnapshot: boolean;
+}): WalletResetSnapshotResultStatus;
+export declare function determineBitcoinDataDirResultStatus(options: {
+    bitcoinDataDirStatus: Awaited<ReturnType<typeof preflightReset>>["bitcoinDataDir"]["status"];
+    deleteSnapshot: boolean;
+    deleteBitcoinDataDir: boolean;
+}): WalletResetBitcoinDataDirResultStatus;
+export declare function resetWallet(options: WalletResetExecutionOptions): Promise<WalletResetResult>;