@cogcoin/client 1.1.5 → 1.1.7

package/dist/wallet/lifecycle/repair.js

@@ -1,366 +1,122 @@
-import { access, constants } from "node:fs/promises";
-import { attachOrStartIndexerDaemon, probeIndexerDaemon, } from "../../bitcoind/indexer-daemon.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
 import { resolveManagedServicePaths } from "../../bitcoind/service-paths.js";
-import { persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
-import { normalizeWalletDescriptorState } from "../descriptor-normalization.js";
-import { acquireFileLock } from "../fs/lock.js";
 import { clearLegacyWalletLockArtifacts } from "../managed-core-wallet.js";
 import { loadMiningRuntimeStatus } from "../mining/runtime-artifacts.js";
-import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
-import { createDefaultWalletSecretProvider, createWalletSecretReference, } from "../state/provider.js";
 import { loadWalletState } from "../state/storage.js";
-import { recreateManagedCoreWalletReplica, verifyManagedCoreWalletReplica } from "./managed-core.js";
+import { acquireWalletControlLock, resolveWalletRepairContext, } from "./context.js";
+import { repairManagedBitcoindStage } from "./repair-bitcoind.js";
+import { repairManagedIndexerStage } from "./repair-indexer.js";
 import { applyRepairStoppedMiningState, cleanupMiningForRepair, persistRepairState, resumeBackgroundMiningAfterRepair, } from "./repair-mining.js";
-import { clearIndexerDaemonArtifacts, clearManagedBitcoindArtifacts, clearOrphanedRepairLocks, ensureIndexerDatabaseHealthy, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, mapIndexerCompatibilityToRepairIssue, verifyIndexerPostRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { clearOrphanedRepairLocks, ensureIndexerDatabaseHealthy, } from "./repair-runtime.js";
 export async function repairWallet(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const probeManagedBitcoind = options.probeBitcoindService ?? probeManagedBitcoindService;
-    const attachManagedBitcoind = options.attachService ?? attachOrStartManagedBitcoindService;
-    const probeManagedIndexerDaemon = options.probeIndexerDaemon ?? probeIndexerDaemon;
-    const attachManagedIndexerDaemon = options.attachIndexerDaemon ?? attachOrStartIndexerDaemon;
+    const context = resolveWalletRepairContext(options);
     await clearOrphanedRepairLocks([
-        paths.walletControlLockPath,
-        paths.miningControlLockPath,
+        context.paths.walletControlLockPath,
+        context.paths.miningControlLockPath,
     ]);
-    const controlLock = await acquireFileLock(paths.walletControlLockPath, {
-        purpose: "wallet-repair",
-        walletRootId: null,
-    });
+    const controlLock = await acquireWalletControlLock(context.paths, "wallet-repair");
     try {
         let loaded;
         try {
             loaded = await loadWalletState({
-                primaryPath: paths.walletStatePath,
-                backupPath: paths.walletStateBackupPath,
+                primaryPath: context.paths.walletStatePath,
+                backupPath: context.paths.walletStateBackupPath,
             }, {
-                provider,
+                provider: context.provider,
             });
         }
         catch {
             throw new Error("local-state-corrupt");
         }
         const recoveredFromBackup = loaded.source === "backup";
-        const secretReference = createWalletSecretReference(loaded.state.walletRootId);
         let repairedState = loaded.state;
         let repairStateNeedsPersist = false;
-        const servicePaths = resolveManagedServicePaths(options.dataDir, repairedState.walletRootId);
+        const servicePaths = resolveManagedServicePaths(context.dataDir, repairedState.walletRootId);
         await clearOrphanedRepairLocks([
             servicePaths.bitcoindLockPath,
             servicePaths.indexerDaemonLockPath,
         ]);
-        const preRepairMiningRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
+        const preRepairMiningRuntime = await loadMiningRuntimeStatus(context.paths.miningStatusPath).catch(() => null);
         const miningCleanup = await cleanupMiningForRepair({
-            paths,
+            paths: context.paths,
             state: repairedState,
             snapshot: preRepairMiningRuntime,
-            nowUnixMs,
+            nowUnixMs: context.nowUnixMs,
         });
         const miningPreRepairRunMode = miningCleanup.preRepairRunMode;
         if (miningPreRepairRunMode !== "stopped" || preRepairMiningRuntime?.runMode !== "stopped") {
             repairedState = applyRepairStoppedMiningState(repairedState);
             repairStateNeedsPersist = true;
         }
-        if (!(options.assumeYes ?? false)) {
+        if (!context.assumeYes) {
             await ensureIndexerDatabaseHealthy({
-                databasePath: options.databasePath,
-                dataDir: options.dataDir,
+                databasePath: context.databasePath,
+                dataDir: context.dataDir,
                 walletRootId: repairedState.walletRootId,
                 resetIfNeeded: false,
             });
         }
-        let bitcoindServiceAction = "none";
-        let bitcoindCompatibilityIssue = "none";
-        let managedCoreReplicaAction = "none";
-        let indexerDaemonAction = "none";
-        let indexerCompatibilityIssue = "none";
-        let initialBitcoindProbe = {
-            compatibility: "unreachable",
-            status: null,
-            error: null,
-        };
-        let resetIndexerDatabase = false;
-        let bitcoindHandle = null;
-        let bitcoindPostRepairHealth = "unavailable";
-        const bitcoindLock = await acquireFileLock(servicePaths.bitcoindLockPath, {
-            purpose: "managed-bitcoind-repair",
-            walletRootId: repairedState.walletRootId,
-            dataDir: options.dataDir,
+        const bitcoindStage = await repairManagedBitcoindStage({
+            context,
+            servicePaths,
+            state: repairedState,
+            recoveredFromBackup,
+            repairStateNeedsPersist,
         });
-        try {
-            initialBitcoindProbe = await probeManagedBitcoind({
-                dataDir: options.dataDir,
-                chain: "main",
-                startHeight: 0,
-                walletRootId: repairedState.walletRootId,
+        repairedState = bitcoindStage.state;
+        repairStateNeedsPersist = bitcoindStage.repairStateNeedsPersist;
+        if (recoveredFromBackup) {
+            repairedState = await persistRepairState({
+                state: repairedState,
+                provider: context.provider,
+                paths: context.paths,
+                nowUnixMs: context.nowUnixMs,
+                replacePrimary: true,
             });
-            bitcoindCompatibilityIssue = mapBitcoindCompatibilityToRepairIssue(initialBitcoindProbe.compatibility);
-            if (initialBitcoindProbe.compatibility === "service-version-mismatch"
-                || initialBitcoindProbe.compatibility === "wallet-root-mismatch"
-                || initialBitcoindProbe.compatibility === "runtime-mismatch") {
-                const processId = initialBitcoindProbe.status?.processId ?? null;
-                if (processId === null) {
-                    throw new Error("managed_bitcoind_process_id_unavailable");
-                }
-                try {
-                    process.kill(processId, "SIGTERM");
-                }
-                catch (error) {
-                    if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
-                        throw error;
-                    }
-                }
-                await waitForProcessExit(processId, 15_000, "managed_bitcoind_stop_timeout");
-                await clearManagedBitcoindArtifacts(servicePaths);
-                bitcoindServiceAction = "stopped-incompatible-service";
-            }
-            else if (initialBitcoindProbe.compatibility === "unreachable") {
-                const hasStaleArtifacts = await Promise.all([
-                    servicePaths.bitcoindStatusPath,
-                    servicePaths.bitcoindPidPath,
-                    servicePaths.bitcoindReadyPath,
-                    servicePaths.bitcoindWalletStatusPath,
-                ].map(pathExists));
-                if (hasStaleArtifacts.some(Boolean)) {
-                    await clearManagedBitcoindArtifacts(servicePaths);
-                    bitcoindServiceAction = "cleared-stale-artifacts";
-                }
-            }
-            else if (initialBitcoindProbe.compatibility === "protocol-error") {
-                throw new Error(initialBitcoindProbe.error ?? "managed_bitcoind_protocol_error");
-            }
-        }
-        finally {
-            await bitcoindLock.release();
+            repairStateNeedsPersist = false;
         }
-        try {
-            bitcoindHandle = await attachManagedBitcoind({
-                dataDir: options.dataDir,
-                chain: "main",
-                startHeight: 0,
-                walletRootId: repairedState.walletRootId,
-            });
-            const bitcoindRpc = (options.rpcFactory ?? createRpcClient)(bitcoindHandle.rpc);
-            const normalizedDescriptorState = await normalizeWalletDescriptorState(repairedState, bitcoindRpc);
-            if (normalizedDescriptorState.changed) {
-                repairedState = normalizedDescriptorState.state;
-                repairStateNeedsPersist = true;
-            }
-            const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
+        else if (repairStateNeedsPersist) {
+            repairedState = await persistRepairState({
                 state: repairedState,
-                access: {
-                    provider,
-                    secretReference,
-                },
-                paths,
-                nowUnixMs,
-                replacePrimary: recoveredFromBackup && !repairStateNeedsPersist,
-                rpc: (options.rpcFactory ?? createRpcClient)(bitcoindHandle.rpc),
+                provider: context.provider,
+                paths: context.paths,
+                nowUnixMs: context.nowUnixMs,
             });
-            repairedState = reconciledCoinControl.state;
-            if (reconciledCoinControl.changed) {
-                repairStateNeedsPersist = false;
-            }
-            let replica = await verifyManagedCoreWalletReplica(repairedState, options.dataDir, {
-                nodeHandle: bitcoindHandle,
-                attachService: options.attachService,
-                rpcFactory: options.rpcFactory,
-            });
-            let recreatedManagedCoreWallet = false;
-            if (replica.proofStatus !== "ready") {
-                repairedState = await recreateManagedCoreWalletReplica(repairedState, provider, paths, options.dataDir, nowUnixMs, {
-                    attachService: options.attachService,
-                    rpcFactory: options.rpcFactory,
-                });
-                recreatedManagedCoreWallet = true;
-                managedCoreReplicaAction = "recreated";
-                repairStateNeedsPersist = false;
-                replica = await verifyManagedCoreWalletReplica(repairedState, options.dataDir, {
-                    nodeHandle: bitcoindHandle,
-                    attachService: options.attachService,
-                    rpcFactory: options.rpcFactory,
-                });
-            }
-            const finalBitcoindStatus = await bitcoindHandle.refreshServiceStatus?.() ?? null;
-            const chainInfo = await bitcoindRpc.getBlockchainInfo();
-            bitcoindPostRepairHealth = mapBitcoindRepairHealth({
-                serviceState: finalBitcoindStatus?.state ?? null,
-                catchingUp: chainInfo.blocks < chainInfo.headers,
-                replica,
-            });
-            if (bitcoindServiceAction === "none" && initialBitcoindProbe.compatibility === "unreachable") {
-                bitcoindServiceAction = "restarted-compatible-service";
-            }
-            let initialIndexerDaemonInstanceId = null;
-            let preAttachIndexerDaemonInstanceId = null;
-            const indexerLock = await acquireFileLock(servicePaths.indexerDaemonLockPath, {
-                purpose: "indexer-daemon-repair",
-                walletRootId: repairedState.walletRootId,
-                dataDir: options.dataDir,
-                databasePath: options.databasePath,
-            });
-            try {
-                const initialProbe = await probeManagedIndexerDaemon({
-                    dataDir: options.dataDir,
-                    walletRootId: repairedState.walletRootId,
-                });
-                indexerCompatibilityIssue = mapIndexerCompatibilityToRepairIssue(initialProbe.compatibility);
-                initialIndexerDaemonInstanceId = initialProbe.status?.daemonInstanceId ?? null;
-                if (initialProbe.compatibility === "compatible") {
-                    await initialProbe.client?.close().catch(() => undefined);
-                }
-                else if (initialProbe.compatibility === "service-version-mismatch"
-                    || initialProbe.compatibility === "wallet-root-mismatch"
-                    || initialProbe.compatibility === "schema-mismatch") {
-                    const processId = initialProbe.status?.processId ?? null;
-                    if (processId === null) {
-                        throw new Error("indexer_daemon_process_id_unavailable");
-                    }
-                    try {
-                        process.kill(processId, "SIGTERM");
-                    }
-                    catch (error) {
-                        if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
-                            throw error;
-                        }
-                    }
-                    await waitForProcessExit(processId);
-                    await clearIndexerDaemonArtifacts(servicePaths);
-                    indexerDaemonAction = "stopped-incompatible-daemon";
-                }
-                else if (initialProbe.compatibility === "unreachable") {
-                    const hasStaleArtifacts = await Promise.all([
-                        servicePaths.indexerDaemonSocketPath,
-                        servicePaths.indexerDaemonStatusPath,
-                    ].map(pathExists));
-                    if (hasStaleArtifacts.some(Boolean)) {
-                        await clearIndexerDaemonArtifacts(servicePaths);
-                        indexerDaemonAction = "cleared-stale-artifacts";
-                    }
-                }
-                else {
-                    throw new Error(initialProbe.error ?? "indexer_daemon_protocol_error");
-                }
-                resetIndexerDatabase = await ensureIndexerDatabaseHealthy({
-                    databasePath: options.databasePath,
-                    dataDir: options.dataDir,
-                    walletRootId: repairedState.walletRootId,
-                    resetIfNeeded: options.assumeYes ?? false,
-                });
-            }
-            finally {
-                await indexerLock.release();
-            }
-            if (recoveredFromBackup) {
-                repairedState = await persistRepairState({
-                    state: repairedState,
-                    provider,
-                    paths,
-                    nowUnixMs,
-                    replacePrimary: true,
-                });
-                repairStateNeedsPersist = false;
-            }
-            else if (repairStateNeedsPersist) {
-                repairedState = await persistRepairState({
-                    state: repairedState,
-                    provider,
-                    paths,
-                    nowUnixMs,
-                });
-                repairStateNeedsPersist = false;
-            }
-            const preAttachProbe = await probeManagedIndexerDaemon({
-                dataDir: options.dataDir,
-                walletRootId: repairedState.walletRootId,
-            });
-            if (preAttachProbe.compatibility === "compatible") {
-                preAttachIndexerDaemonInstanceId = preAttachProbe.status?.daemonInstanceId ?? null;
-                await preAttachProbe.client?.close().catch(() => undefined);
-            }
-            else if (preAttachProbe.compatibility !== "unreachable") {
-                throw new Error(preAttachProbe.error ?? "indexer_daemon_protocol_error");
-            }
-            const daemon = await attachManagedIndexerDaemon({
-                dataDir: options.dataDir,
-                databasePath: options.databasePath,
-                walletRootId: repairedState.walletRootId,
-            });
-            try {
-                const { health: indexerPostRepairHealth, daemonInstanceId: postRepairDaemonInstanceId, } = await verifyIndexerPostRepairHealth({
-                    daemon,
-                    probeIndexerDaemon: probeManagedIndexerDaemon,
-                    dataDir: options.dataDir,
-                    walletRootId: repairedState.walletRootId,
-                    nowUnixMs,
-                });
-                const restartedIndexerDaemon = indexerDaemonAction !== "none" || preAttachProbe.compatibility === "unreachable";
-                if (restartedIndexerDaemon
-                    && initialIndexerDaemonInstanceId !== null
-                    && postRepairDaemonInstanceId === initialIndexerDaemonInstanceId) {
-                    throw new Error("indexer_daemon_repair_identity_not_rotated");
-                }
-                if (!restartedIndexerDaemon
-                    && preAttachProbe.compatibility === "compatible"
-                    && preAttachIndexerDaemonInstanceId !== null
-                    && postRepairDaemonInstanceId !== preAttachIndexerDaemonInstanceId) {
-                    throw new Error("indexer_daemon_repair_identity_changed");
-                }
-                if (indexerDaemonAction === "none" && preAttachProbe.compatibility === "unreachable") {
-                    indexerDaemonAction = "restarted-compatible-daemon";
-                }
-                const miningResume = await resumeBackgroundMiningAfterRepair({
-                    miningPreRepairRunMode,
-                    provider,
-                    paths,
-                    repairedState,
-                    bitcoindPostRepairHealth,
-                    indexerPostRepairHealth,
-                    dataDir: options.dataDir,
-                    databasePath: options.databasePath,
-                    startBackgroundMining: options.startBackgroundMining,
-                });
-                await clearLegacyWalletLockArtifacts(paths.walletRuntimeRoot);
-                return {
-                    walletRootId: repairedState.walletRootId,
-                    recoveredFromBackup,
-                    recreatedManagedCoreWallet,
-                    resetIndexerDatabase,
-                    bitcoindServiceAction,
-                    bitcoindCompatibilityIssue,
-                    managedCoreReplicaAction,
-                    bitcoindPostRepairHealth,
-                    indexerDaemonAction,
-                    indexerCompatibilityIssue,
-                    indexerPostRepairHealth,
-                    miningPreRepairRunMode,
-                    miningResumeAction: miningResume.miningResumeAction,
-                    miningPostRepairRunMode: miningResume.miningPostRepairRunMode,
-                    miningResumeError: miningResume.miningResumeError,
-                    note: resetIndexerDatabase
-                        ? "Indexer artifacts were reset and may still be catching up."
-                        : null,
-                };
-            }
-            finally {
-                await daemon.close().catch(() => undefined);
-            }
-        }
-        finally {
-            await bitcoindHandle?.stop?.().catch(() => undefined);
+            repairStateNeedsPersist = false;
         }
+        const indexerStage = await repairManagedIndexerStage({
+            context,
+            servicePaths,
+            state: repairedState,
+        });
+        const miningResume = await resumeBackgroundMiningAfterRepair({
+            miningPreRepairRunMode,
+            provider: context.provider,
+            paths: context.paths,
+            repairedState,
+            bitcoindPostRepairHealth: bitcoindStage.bitcoindPostRepairHealth,
+            indexerPostRepairHealth: indexerStage.indexerPostRepairHealth,
+        });
+        await clearLegacyWalletLockArtifacts(context.paths.walletRuntimeRoot);
+        return {
+            walletRootId: repairedState.walletRootId,
+            recoveredFromBackup,
+            recreatedManagedCoreWallet: bitcoindStage.recreatedManagedCoreWallet,
+            resetIndexerDatabase: indexerStage.resetIndexerDatabase,
+            bitcoindServiceAction: bitcoindStage.bitcoindServiceAction,
+            bitcoindCompatibilityIssue: bitcoindStage.bitcoindCompatibilityIssue,
+            managedCoreReplicaAction: bitcoindStage.managedCoreReplicaAction,
+            bitcoindPostRepairHealth: bitcoindStage.bitcoindPostRepairHealth,
+            indexerDaemonAction: indexerStage.indexerDaemonAction,
+            indexerCompatibilityIssue: indexerStage.indexerCompatibilityIssue,
+            indexerPostRepairHealth: indexerStage.indexerPostRepairHealth,
+            miningPreRepairRunMode,
+            miningResumeAction: miningResume.miningResumeAction,
+            miningPostRepairRunMode: miningResume.miningPostRepairRunMode,
+            miningResumeError: miningResume.miningResumeError,
+            note: indexerStage.resetIndexerDatabase
+                ? "Indexer artifacts were reset and may still be catching up."
+                : null,
+        };
     }
     finally {
         await controlLock.release();

package/dist/wallet/lifecycle/setup-prompts.d.ts

@@ -0,0 +1,7 @@
+import type { WalletInitializationResult, WalletPrompter } from "./types.js";
+export declare function promptForRestoreMnemonic(prompter: WalletPrompter): Promise<string>;
+export declare function promptForInitializationMode(prompter: WalletPrompter): Promise<Exclude<WalletInitializationResult["setupMode"], "existing">>;
+export declare function confirmTypedAcknowledgement(prompter: WalletPrompter, expected: string, message: string, errorCode?: string): Promise<void>;
+export declare function writeMnemonicReveal(prompter: WalletPrompter, phrase: string, introLines: readonly string[]): void;
+export declare function confirmMnemonic(prompter: WalletPrompter, words: readonly string[]): Promise<void>;
+export declare function clearSensitiveDisplay(prompter: WalletPrompter, scope: "mnemonic-reveal" | "restore-mnemonic-entry"): Promise<void>;

package/dist/wallet/lifecycle/setup-prompts.js

@@ -0,0 +1,88 @@
+import { createMnemonicConfirmationChallenge, isEnglishMnemonicWord, validateEnglishMnemonic, } from "../material.js";
+import { renderWalletMnemonicRevealArt } from "../mnemonic-art.js";
+async function promptRequiredValue(prompter, message) {
+    const value = (await prompter.prompt(message)).trim();
+    if (value === "") {
+        throw new Error("wallet_prompt_value_required");
+    }
+    return value;
+}
+export async function promptForRestoreMnemonic(prompter) {
+    const words = [];
+    for (let index = 0; index < 24; index += 1) {
+        const word = (await promptRequiredValue(prompter, `Word ${index + 1} of 24: `)).toLowerCase();
+        if (!isEnglishMnemonicWord(word)) {
+            throw new Error("wallet_restore_mnemonic_invalid");
+        }
+        words.push(word);
+    }
+    const phrase = words.join(" ");
+    if (!validateEnglishMnemonic(phrase)) {
+        throw new Error("wallet_restore_mnemonic_invalid");
+    }
+    return phrase;
+}
+export async function promptForInitializationMode(prompter) {
+    if (prompter.selectOption != null) {
+        return await prompter.selectOption({
+            message: "How should Cogcoin set up this wallet?",
+            options: [
+                {
+                    label: "Create new wallet",
+                    description: "Generate a fresh 24-word recovery phrase.",
+                    value: "generated",
+                },
+                {
+                    label: "Restore existing wallet",
+                    description: "Enter an existing 24-word recovery phrase.",
+                    value: "restored",
+                },
+            ],
+            initialValue: "generated",
+        });
+    }
+    prompter.writeLine("How should Cogcoin set up this wallet?");
+    prompter.writeLine("1. Create new wallet");
+    prompter.writeLine("2. Restore existing wallet");
+    while (true) {
+        const answer = (await prompter.prompt("Choice [1-2]: ")).trim();
+        if (answer === "1") {
+            return "generated";
+        }
+        if (answer === "2") {
+            return "restored";
+        }
+        prompter.writeLine("Enter 1 or 2.");
+    }
+}
+export async function confirmTypedAcknowledgement(prompter, expected, message, errorCode = "wallet_typed_confirmation_rejected") {
+    const answer = (await prompter.prompt(message)).trim();
+    if (answer !== expected) {
+        throw new Error(errorCode);
+    }
+}
+export function writeMnemonicReveal(prompter, phrase, introLines) {
+    const words = phrase.trim().split(/\s+/);
+    for (const line of introLines) {
+        prompter.writeLine(line);
+    }
+    for (const line of renderWalletMnemonicRevealArt(words)) {
+        prompter.writeLine(line);
+    }
+    prompter.writeLine("Single-line copy:");
+    prompter.writeLine(phrase);
+}
+export async function confirmMnemonic(prompter, words) {
+    const challenge = createMnemonicConfirmationChallenge([...words]);
+    for (const entry of challenge) {
+        const answer = (await prompter.prompt(`Confirm word #${entry.index + 1}: `)).trim().toLowerCase();
+        if (answer !== entry.word) {
+            throw new Error(`wallet_init_confirmation_failed_word_${entry.index + 1}`);
+        }
+    }
+}
+export async function clearSensitiveDisplay(prompter, scope) {
+    await Promise.resolve()
+        .then(() => prompter.clearSensitiveDisplay?.(scope))
+        .catch(() => undefined);
+}

package/dist/wallet/lifecycle/setup-state.d.ts

@@ -0,0 +1,26 @@
+import { deriveWalletMaterialFromMnemonic } from "../material.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletSetupContext } from "./types.js";
+export type WalletMaterial = ReturnType<typeof deriveWalletMaterialFromMnemonic>;
+export declare function clearPendingInitialization(paths: WalletRuntimePaths, provider: WalletSecretProvider): Promise<void>;
+export declare function loadOrCreatePendingInitializationMaterial(options: {
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    nowUnixMs: number;
+}): Promise<WalletMaterial>;
+export declare function createInitialWalletState(options: {
+    walletRootId: string;
+    nowUnixMs: number;
+    material: WalletMaterial;
+    internalCoreWalletPassphrase: string;
+}): WalletStateV1;
+export declare function persistInitializedWallet(options: {
+    context: WalletSetupContext;
+    provider: WalletSecretProvider;
+    material: WalletMaterial;
+}): Promise<{
+    walletRootId: string;
+    state: WalletStateV1;
+}>;