@cogcoin/client 1.1.4 → 1.1.6

package/dist/wallet/lifecycle/repair-runtime.js

@@ -0,0 +1,206 @@
+import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import { attachOrStartIndexerDaemon, probeIndexerDaemon, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { probeManagedBitcoindService } from "../../bitcoind/service.js";
+import { resolveManagedServicePaths } from "../../bitcoind/service-paths.js";
+import { openClient } from "../../client.js";
+import { openSqliteStore } from "../../sqlite/index.js";
+import { clearOrphanedFileLock } from "../fs/lock.js";
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureIndexerDatabaseHealthy(options) {
+    try {
+        if (await pathExists(options.databasePath)) {
+            const header = await readFile(options.databasePath).then((buffer) => buffer.subarray(0, 16).toString("utf8"));
+            if (header.length > 0 && header !== "SQLite format 3\u0000") {
+                throw new Error("indexer_database_not_sqlite");
+            }
+        }
+        const store = await openSqliteStore({ filename: options.databasePath });
+        try {
+            const client = await openClient({ store });
+            try {
+                await client.getTip();
+            }
+            finally {
+                await client.close();
+            }
+        }
+        finally {
+            await store.close();
+        }
+        return false;
+    }
+    catch {
+        if (!options.resetIfNeeded) {
+            throw new Error("wallet_repair_indexer_reset_requires_yes");
+        }
+        await rm(options.databasePath, { force: true }).catch(() => undefined);
+        await rm(`${options.databasePath}-wal`, { force: true }).catch(() => undefined);
+        await rm(`${options.databasePath}-shm`, { force: true }).catch(() => undefined);
+        await mkdir(dirname(options.databasePath), { recursive: true });
+        return true;
+    }
+}
+export function mapIndexerCompatibilityToRepairIssue(compatibility) {
+    switch (compatibility) {
+        case "service-version-mismatch":
+            return "service-version-mismatch";
+        case "wallet-root-mismatch":
+            return "wallet-root-mismatch";
+        case "schema-mismatch":
+            return "schema-mismatch";
+        default:
+            return "none";
+    }
+}
+export function mapBitcoindCompatibilityToRepairIssue(compatibility) {
+    switch (compatibility) {
+        case "service-version-mismatch":
+            return "service-version-mismatch";
+        case "wallet-root-mismatch":
+            return "wallet-root-mismatch";
+        case "runtime-mismatch":
+            return "runtime-mismatch";
+        default:
+            return "none";
+    }
+}
+export function mapBitcoindRepairHealth(options) {
+    if (options.serviceState === null) {
+        return "unavailable";
+    }
+    if (options.serviceState === "starting" || options.serviceState === "stopping") {
+        return "starting";
+    }
+    if (options.serviceState !== "ready") {
+        return "failed";
+    }
+    if (options.replica?.proofStatus === "missing" || options.replica?.proofStatus === "mismatch") {
+        return "failed";
+    }
+    if (options.catchingUp) {
+        return "catching-up";
+    }
+    return "ready";
+}
+function mapLeaseStateToRepairHealth(state) {
+    switch (state) {
+        case "synced":
+            return "synced";
+        case "catching-up":
+        case "reorging":
+            return "catching-up";
+        case "starting":
+        case "stopping":
+            return "starting";
+        default:
+            return "failed";
+    }
+}
+const INDEXER_DAEMON_HEARTBEAT_STALE_MS = 15_000;
+export async function verifyIndexerPostRepairHealth(options) {
+    try {
+        const lease = await readSnapshotWithRetry(options.daemon, options.walletRootId);
+        return {
+            health: mapLeaseStateToRepairHealth(lease.status.state),
+            daemonInstanceId: lease.status.daemonInstanceId,
+        };
+    }
+    catch (leaseError) {
+        const probe = await options.probeIndexerDaemon({
+            dataDir: options.dataDir,
+            walletRootId: options.walletRootId,
+        });
+        try {
+            if (probe.compatibility === "compatible"
+                && probe.status !== null
+                && (options.nowUnixMs - probe.status.heartbeatAtUnixMs) <= INDEXER_DAEMON_HEARTBEAT_STALE_MS
+                && (probe.status.state === "starting" || probe.status.state === "catching-up" || probe.status.state === "reorging")) {
+                return {
+                    health: mapLeaseStateToRepairHealth(probe.status.state),
+                    daemonInstanceId: probe.status.daemonInstanceId,
+                };
+            }
+        }
+        finally {
+            await probe.client?.close().catch(() => undefined);
+        }
+        throw leaseError;
+    }
+}
+export async function isProcessAlive(pid) {
+    if (pid === null) {
+        return false;
+    }
+    try {
+        process.kill(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, errorCode = "indexer_daemon_stop_timeout") {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!await isProcessAlive(pid)) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(errorCode);
+}
+export async function clearIndexerDaemonArtifacts(servicePaths) {
+    await rm(servicePaths.indexerDaemonStatusPath, { force: true }).catch(() => undefined);
+    await rm(servicePaths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
+}
+export async function clearManagedBitcoindArtifacts(servicePaths) {
+    await rm(servicePaths.bitcoindStatusPath, { force: true }).catch(() => undefined);
+    await rm(servicePaths.bitcoindPidPath, { force: true }).catch(() => undefined);
+    await rm(servicePaths.bitcoindReadyPath, { force: true }).catch(() => undefined);
+    await rm(servicePaths.bitcoindWalletStatusPath, { force: true }).catch(() => undefined);
+}
+export async function stopRecordedManagedProcess(pid, errorCode) {
+    if (pid === null || !await isProcessAlive(pid)) {
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+            throw error;
+        }
+    }
+    try {
+        await waitForProcessExit(pid, 5_000, errorCode);
+        return;
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+                throw error;
+            }
+        }
+    }
+    await waitForProcessExit(pid, 5_000, errorCode);
+}
+export async function clearOrphanedRepairLocks(lockPaths) {
+    for (const lockPath of lockPaths) {
+        await clearOrphanedFileLock(lockPath, isProcessAlive);
+    }
+}

package/dist/wallet/lifecycle/repair.d.ts

@@ -0,0 +1,9 @@
+import type { WalletRepairDependencies, WalletRepairResult } from "./types.js";
+export declare function repairWallet(options: {
+    dataDir: string;
+    databasePath: string;
+    provider?: import("../state/provider.js").WalletSecretProvider;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: import("../runtime.js").WalletRuntimePaths;
+} & WalletRepairDependencies): Promise<WalletRepairResult>;

package/dist/wallet/lifecycle/repair.js

@@ -0,0 +1,127 @@
+import { resolveManagedServicePaths } from "../../bitcoind/service-paths.js";
+import { clearLegacyWalletLockArtifacts } from "../managed-core-wallet.js";
+import { loadMiningRuntimeStatus } from "../mining/runtime-artifacts.js";
+import { loadWalletState } from "../state/storage.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 { clearOrphanedRepairLocks, ensureIndexerDatabaseHealthy, } from "./repair-runtime.js";
+export async function repairWallet(options) {
+    const context = resolveWalletRepairContext(options);
+    await clearOrphanedRepairLocks([
+        context.paths.walletControlLockPath,
+        context.paths.miningControlLockPath,
+    ]);
+    const controlLock = await acquireWalletControlLock(context.paths, "wallet-repair");
+    try {
+        let loaded;
+        try {
+            loaded = await loadWalletState({
+                primaryPath: context.paths.walletStatePath,
+                backupPath: context.paths.walletStateBackupPath,
+            }, {
+                provider: context.provider,
+            });
+        }
+        catch {
+            throw new Error("local-state-corrupt");
+        }
+        const recoveredFromBackup = loaded.source === "backup";
+        let repairedState = loaded.state;
+        let repairStateNeedsPersist = false;
+        const servicePaths = resolveManagedServicePaths(context.dataDir, repairedState.walletRootId);
+        await clearOrphanedRepairLocks([
+            servicePaths.bitcoindLockPath,
+            servicePaths.indexerDaemonLockPath,
+        ]);
+        const preRepairMiningRuntime = await loadMiningRuntimeStatus(context.paths.miningStatusPath).catch(() => null);
+        const miningCleanup = await cleanupMiningForRepair({
+            paths: context.paths,
+            state: repairedState,
+            snapshot: preRepairMiningRuntime,
+            nowUnixMs: context.nowUnixMs,
+        });
+        const miningPreRepairRunMode = miningCleanup.preRepairRunMode;
+        if (miningPreRepairRunMode !== "stopped" || preRepairMiningRuntime?.runMode !== "stopped") {
+            repairedState = applyRepairStoppedMiningState(repairedState);
+            repairStateNeedsPersist = true;
+        }
+        if (!context.assumeYes) {
+            await ensureIndexerDatabaseHealthy({
+                databasePath: context.databasePath,
+                dataDir: context.dataDir,
+                walletRootId: repairedState.walletRootId,
+                resetIfNeeded: false,
+            });
+        }
+        const bitcoindStage = await repairManagedBitcoindStage({
+            context,
+            servicePaths,
+            state: repairedState,
+            recoveredFromBackup,
+            repairStateNeedsPersist,
+        });
+        repairedState = bitcoindStage.state;
+        repairStateNeedsPersist = bitcoindStage.repairStateNeedsPersist;
+        if (recoveredFromBackup) {
+            repairedState = await persistRepairState({
+                state: repairedState,
+                provider: context.provider,
+                paths: context.paths,
+                nowUnixMs: context.nowUnixMs,
+                replacePrimary: true,
+            });
+            repairStateNeedsPersist = false;
+        }
+        else if (repairStateNeedsPersist) {
+            repairedState = await persistRepairState({
+                state: repairedState,
+                provider: context.provider,
+                paths: context.paths,
+                nowUnixMs: context.nowUnixMs,
+            });
+            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,
+            dataDir: context.dataDir,
+            databasePath: context.databasePath,
+            startBackgroundMining: context.startBackgroundMining,
+        });
+        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;
+}>;

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

@@ -0,0 +1,159 @@
+import { randomBytes } from "node:crypto";
+import { withClaimedUninitializedManagedRuntime } from "../../bitcoind/service.js";
+import { createInternalCoreWalletPassphrase, deriveWalletMaterialFromMnemonic, generateWalletMaterial, } from "../material.js";
+import { clearLegacyWalletLockArtifacts } from "../managed-core-wallet.js";
+import { clearWalletPendingInitializationState, loadWalletPendingInitializationStateOrNull, saveWalletPendingInitializationState, } from "../state/pending-init.js";
+import { createWalletPendingInitSecretReference, createWalletRootId, createWalletSecretReference, } from "../state/provider.js";
+import { saveWalletState } from "../state/storage.js";
+import { importDescriptorIntoManagedCoreWallet, sanitizeWalletName } from "./managed-core.js";
+function resolvePendingInitializationStoragePaths(paths) {
+    return {
+        primaryPath: paths.walletInitPendingPath,
+        backupPath: paths.walletInitPendingBackupPath,
+    };
+}
+export async function clearPendingInitialization(paths, provider) {
+    await clearWalletPendingInitializationState(resolvePendingInitializationStoragePaths(paths), {
+        provider,
+        secretReference: createWalletPendingInitSecretReference(paths.walletStateRoot),
+    });
+}
+export async function loadOrCreatePendingInitializationMaterial(options) {
+    try {
+        const loaded = await loadWalletPendingInitializationStateOrNull(resolvePendingInitializationStoragePaths(options.paths), {
+            provider: options.provider,
+        });
+        if (loaded !== null) {
+            return deriveWalletMaterialFromMnemonic(loaded.state.mnemonic.phrase);
+        }
+    }
+    catch {
+        await clearPendingInitialization(options.paths, options.provider);
+    }
+    const material = generateWalletMaterial();
+    const secretReference = createWalletPendingInitSecretReference(options.paths.walletStateRoot);
+    const pendingState = {
+        schemaVersion: 1,
+        createdAtUnixMs: options.nowUnixMs,
+        mnemonic: {
+            phrase: material.mnemonic.phrase,
+            language: material.mnemonic.language,
+        },
+    };
+    await options.provider.storeSecret(secretReference.keyId, randomBytes(32));
+    try {
+        await saveWalletPendingInitializationState(resolvePendingInitializationStoragePaths(options.paths), pendingState, {
+            provider: options.provider,
+            secretReference,
+        });
+    }
+    catch (error) {
+        await options.provider.deleteSecret(secretReference.keyId).catch(() => undefined);
+        throw error;
+    }
+    return material;
+}
+export function createInitialWalletState(options) {
+    return {
+        schemaVersion: 5,
+        stateRevision: 1,
+        lastWrittenAtUnixMs: options.nowUnixMs,
+        walletRootId: options.walletRootId,
+        network: "mainnet",
+        localScriptPubKeyHexes: [options.material.funding.scriptPubKeyHex],
+        mnemonic: {
+            phrase: options.material.mnemonic.phrase,
+            language: options.material.mnemonic.language,
+        },
+        keys: {
+            masterFingerprintHex: options.material.keys.masterFingerprintHex,
+            accountPath: options.material.keys.accountPath,
+            accountXprv: options.material.keys.accountXprv,
+            accountXpub: options.material.keys.accountXpub,
+        },
+        descriptor: {
+            privateExternal: options.material.descriptor.privateExternal,
+            publicExternal: options.material.descriptor.publicExternal,
+            checksum: options.material.descriptor.checksum,
+            rangeEnd: options.material.descriptor.rangeEnd,
+            safetyMargin: options.material.descriptor.safetyMargin,
+        },
+        funding: {
+            address: options.material.funding.address,
+            scriptPubKeyHex: options.material.funding.scriptPubKeyHex,
+        },
+        walletBirthTime: Math.floor(options.nowUnixMs / 1000),
+        managedCoreWallet: {
+            walletName: sanitizeWalletName(options.walletRootId),
+            internalPassphrase: options.internalCoreWalletPassphrase,
+            descriptorChecksum: null,
+            walletAddress: null,
+            walletScriptPubKeyHex: null,
+            proofStatus: "not-proven",
+            lastImportedAtUnixMs: null,
+            lastVerifiedAtUnixMs: null,
+        },
+        domains: [],
+        miningState: {
+            runMode: "stopped",
+            state: "idle",
+            pauseReason: null,
+            currentPublishState: "none",
+            currentDomain: null,
+            currentDomainId: null,
+            currentDomainIndex: null,
+            currentSenderScriptPubKeyHex: null,
+            currentTxid: null,
+            currentWtxid: null,
+            currentFeeRateSatVb: null,
+            currentAbsoluteFeeSats: null,
+            currentScore: null,
+            currentSentence: null,
+            currentEncodedSentenceBytesHex: null,
+            currentBip39WordIndices: null,
+            currentBlendSeedHex: null,
+            currentBlockTargetHeight: null,
+            currentReferencedBlockHashDisplay: null,
+            currentIntentFingerprintHex: null,
+            livePublishInMempool: null,
+            currentPublishDecision: null,
+            replacementCount: 0,
+            currentBlockFeeSpentSats: "0",
+            sessionFeeSpentSats: "0",
+            lifetimeFeeSpentSats: "0",
+            sharedMiningConflictOutpoint: null,
+        },
+        pendingMutations: [],
+    };
+}
+export async function persistInitializedWallet(options) {
+    const walletRootId = createWalletRootId();
+    const internalCoreWalletPassphrase = createInternalCoreWalletPassphrase();
+    const secretReference = createWalletSecretReference(walletRootId);
+    await options.provider.storeSecret(secretReference.keyId, randomBytes(32));
+    const initialState = createInitialWalletState({
+        walletRootId,
+        nowUnixMs: options.context.nowUnixMs,
+        material: options.material,
+        internalCoreWalletPassphrase,
+    });
+    const verifiedState = await withClaimedUninitializedManagedRuntime({
+        dataDir: options.context.dataDir,
+        walletRootId,
+    }, async () => {
+        await saveWalletState({
+            primaryPath: options.context.paths.walletStatePath,
+            backupPath: options.context.paths.walletStateBackupPath,
+        }, initialState, {
+            provider: options.provider,
+            secretReference,
+        });
+        return await importDescriptorIntoManagedCoreWallet(initialState, options.provider, options.context.paths, options.context.dataDir, options.context.nowUnixMs, options.context.attachService, options.context.rpcFactory);
+    });
+    await clearLegacyWalletLockArtifacts(options.context.paths.walletRuntimeRoot);
+    await clearPendingInitialization(options.context.paths, options.provider);
+    return {
+        walletRootId,
+        state: verifiedState,
+    };
+}

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

@@ -0,0 +1,15 @@
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { WalletInitializationResult, WalletPrompter, WalletSetupDependencies } from "./types.js";
+export declare function initializeWallet(options: {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    paths?: import("../runtime.js").WalletRuntimePaths;
+} & WalletSetupDependencies): Promise<WalletInitializationResult>;
+export declare function showWalletMnemonic(options: {
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    paths?: import("../runtime.js").WalletRuntimePaths;
+} & WalletSetupDependencies): Promise<void>;