@cogcoin/client 1.1.4 → 1.1.6

package/dist/wallet/lifecycle/setup.js

@@ -0,0 +1,124 @@
+import { deriveWalletMaterialFromMnemonic } from "../material.js";
+import { ensureClientPasswordConfigured, withInteractiveWalletSecretProvider, } from "../state/provider.js";
+import { loadWalletStateForAccess, mapWalletReadAccessError } from "./access.js";
+import { acquireWalletControlLock, resolveWalletManagedCoreContext, resolveWalletSetupContext, walletStateExists, } from "./context.js";
+import { clearSensitiveDisplay, confirmMnemonic, confirmTypedAcknowledgement, promptForInitializationMode, promptForRestoreMnemonic, writeMnemonicReveal, } from "./setup-prompts.js";
+import { clearPendingInitialization, loadOrCreatePendingInitializationMaterial, persistInitializedWallet, } from "./setup-state.js";
+export async function initializeWallet(options) {
+    const context = resolveWalletSetupContext(options);
+    if (!context.prompter.isInteractive) {
+        throw new Error("wallet_init_requires_tty");
+    }
+    const interactiveProvider = withInteractiveWalletSecretProvider(context.provider, context.prompter);
+    const controlLock = await acquireWalletControlLock(context.paths, "wallet-init");
+    try {
+        const passwordAction = await ensureClientPasswordConfigured(context.provider, context.prompter);
+        if (await walletStateExists(context.paths)) {
+            await clearPendingInitialization(context.paths, interactiveProvider);
+            const loaded = await loadWalletStateForAccess({
+                ...context,
+                provider: interactiveProvider,
+                dataDir: context.dataDir,
+            });
+            return {
+                setupMode: "existing",
+                passwordAction,
+                walletAction: "already-initialized",
+                walletRootId: loaded.state.walletRootId,
+                fundingAddress: loaded.state.funding.address,
+                state: loaded.state,
+            };
+        }
+        const setupMode = await promptForInitializationMode(context.prompter);
+        let material;
+        if (setupMode === "generated") {
+            material = await loadOrCreatePendingInitializationMaterial({
+                provider: interactiveProvider,
+                paths: context.paths,
+                nowUnixMs: context.nowUnixMs,
+            });
+            writeMnemonicReveal(context.prompter, material.mnemonic.phrase, [
+                "Cogcoin Wallet Initialization",
+                "Write down this 24-word recovery phrase.",
+                "The same phrase will be shown again until confirmation succeeds:",
+                "",
+            ]);
+            try {
+                await confirmMnemonic(context.prompter, material.mnemonic.words);
+            }
+            finally {
+                await clearSensitiveDisplay(context.prompter, "mnemonic-reveal");
+            }
+        }
+        else {
+            let mnemonicPhrase;
+            try {
+                mnemonicPhrase = await promptForRestoreMnemonic(context.prompter);
+            }
+            finally {
+                await clearSensitiveDisplay(context.prompter, "restore-mnemonic-entry");
+            }
+            await clearPendingInitialization(context.paths, interactiveProvider);
+            material = deriveWalletMaterialFromMnemonic(mnemonicPhrase);
+        }
+        const initialized = await persistInitializedWallet({
+            context,
+            provider: interactiveProvider,
+            material,
+        });
+        return {
+            setupMode,
+            passwordAction,
+            walletAction: "initialized",
+            walletRootId: initialized.walletRootId,
+            fundingAddress: initialized.state.funding.address,
+            state: initialized.state,
+        };
+    }
+    finally {
+        await controlLock.release();
+    }
+}
+export async function showWalletMnemonic(options) {
+    const context = {
+        ...resolveWalletManagedCoreContext({
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+            attachService: options.attachService,
+            rpcFactory: options.rpcFactory,
+        }),
+        prompter: options.prompter,
+    };
+    if (!context.prompter.isInteractive) {
+        throw new Error("wallet_show_mnemonic_requires_tty");
+    }
+    const interactiveProvider = withInteractiveWalletSecretProvider(context.provider, context.prompter);
+    const controlLock = await acquireWalletControlLock(context.paths, "wallet-show-mnemonic");
+    try {
+        if (!await walletStateExists(context.paths)) {
+            throw new Error("wallet_uninitialized");
+        }
+        const loaded = await loadWalletStateForAccess({
+            ...context,
+            provider: interactiveProvider,
+        }).catch((error) => {
+            throw mapWalletReadAccessError(error);
+        });
+        await confirmTypedAcknowledgement(context.prompter, "show mnemonic", "Type \"show mnemonic\" to continue: ", "wallet_show_mnemonic_typed_ack_required");
+        writeMnemonicReveal(context.prompter, loaded.state.mnemonic.phrase, [
+            "Cogcoin Wallet Recovery Phrase",
+            "This 24-word recovery phrase controls the wallet.",
+            "",
+        ]);
+        try {
+            await context.prompter.prompt("Press Enter to clear the recovery phrase from the screen: ");
+        }
+        finally {
+            await clearSensitiveDisplay(context.prompter, "mnemonic-reveal");
+        }
+    }
+    finally {
+        await controlLock.release();
+    }
+}

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

@@ -0,0 +1,156 @@
+import type { attachOrStartIndexerDaemon, probeIndexerDaemon } from "../../bitcoind/indexer-daemon.js";
+import type { createRpcClient } from "../../bitcoind/node.js";
+import type { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
+import type { RpcListUnspentEntry } from "../../bitcoind/types.js";
+import type { requestMiningGenerationPreemption } from "../mining/coordination.js";
+import type { startBackgroundMining } from "../mining/runner.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { WalletSecretProvider } from "../state/provider.js";
+import type { WalletStateV1 } from "../types.js";
+export interface WalletPrompter {
+    readonly isInteractive: boolean;
+    writeLine(message: string): void;
+    prompt(message: string): Promise<string>;
+    promptHidden?(message: string): Promise<string>;
+    selectOption?(options: {
+        message: string;
+        options: Array<{
+            label: string;
+            description?: string | null;
+            value: string;
+        }>;
+        initialValue?: string | null;
+        footer?: string | null;
+    }): Promise<string>;
+    clearSensitiveDisplay?(scope: "mnemonic-reveal" | "restore-mnemonic-entry"): void | Promise<void>;
+}
+export interface WalletInitializationResult {
+    setupMode: "generated" | "restored" | "existing";
+    passwordAction: "created" | "migrated" | "already-configured";
+    walletAction: "initialized" | "already-initialized";
+    walletRootId: string;
+    fundingAddress: string;
+    state: WalletStateV1;
+}
+export interface WalletRepairResult {
+    walletRootId: string;
+    recoveredFromBackup: boolean;
+    recreatedManagedCoreWallet: boolean;
+    resetIndexerDatabase: boolean;
+    bitcoindServiceAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-service" | "restarted-compatible-service";
+    bitcoindCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch";
+    managedCoreReplicaAction: "none" | "recreated";
+    bitcoindPostRepairHealth: "ready" | "catching-up" | "starting" | "failed" | "unavailable";
+    indexerDaemonAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-daemon" | "restarted-compatible-daemon";
+    indexerCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "schema-mismatch";
+    indexerPostRepairHealth: "starting" | "catching-up" | "synced" | "failed";
+    miningPreRepairRunMode: "stopped" | "foreground" | "background";
+    miningResumeAction: "none" | "skipped-not-resumable" | "skipped-post-repair-blocked" | "resumed-background" | "resume-failed";
+    miningPostRepairRunMode: "stopped" | "background";
+    miningResumeError: string | null;
+    note: string | null;
+}
+export interface WalletLifecycleRpcClient {
+    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;
+    }>;
+    unloadWallet?(walletName: string, loadOnStartup?: boolean): Promise<null>;
+    listWallets(): Promise<string[]>;
+    listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+        headers: number;
+    }>;
+}
+export interface WalletManagedCoreDependencies {
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}
+export interface WalletSetupDependencies extends WalletManagedCoreDependencies {
+}
+export interface WalletLifecycleResolvedContext {
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    nowUnixMs: number;
+}
+export interface WalletManagedCoreContext extends WalletLifecycleResolvedContext {
+    attachService: NonNullable<WalletManagedCoreDependencies["attachService"]>;
+    rpcFactory: NonNullable<WalletManagedCoreDependencies["rpcFactory"]>;
+}
+export interface WalletAccessContext extends WalletManagedCoreContext {
+    dataDir?: string;
+}
+export interface WalletLoadedState {
+    state: WalletStateV1;
+    source: "primary" | "backup";
+}
+export interface WalletSetupContext extends WalletManagedCoreContext {
+    dataDir: string;
+    prompter: WalletPrompter;
+}
+export interface WalletRepairDependencies extends WalletManagedCoreDependencies {
+    probeBitcoindService?: typeof probeManagedBitcoindService;
+    attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
+    probeIndexerDaemon?: typeof probeIndexerDaemon;
+    requestMiningPreemption?: typeof requestMiningGenerationPreemption;
+    startBackgroundMining?: typeof startBackgroundMining;
+}
+export interface WalletRepairContext extends WalletManagedCoreContext {
+    dataDir: string;
+    databasePath: string;
+    assumeYes: boolean;
+    probeBitcoindService: NonNullable<WalletRepairDependencies["probeBitcoindService"]>;
+    attachIndexerDaemon: NonNullable<WalletRepairDependencies["attachIndexerDaemon"]>;
+    probeIndexerDaemon: NonNullable<WalletRepairDependencies["probeIndexerDaemon"]>;
+    requestMiningPreemption?: WalletRepairDependencies["requestMiningPreemption"];
+    startBackgroundMining?: WalletRepairDependencies["startBackgroundMining"];
+}
+export interface WalletBitcoindRepairStageResult {
+    state: WalletStateV1;
+    repairStateNeedsPersist: boolean;
+    recreatedManagedCoreWallet: boolean;
+    bitcoindServiceAction: WalletRepairResult["bitcoindServiceAction"];
+    bitcoindCompatibilityIssue: WalletRepairResult["bitcoindCompatibilityIssue"];
+    managedCoreReplicaAction: WalletRepairResult["managedCoreReplicaAction"];
+    bitcoindPostRepairHealth: WalletRepairResult["bitcoindPostRepairHealth"];
+}
+export interface WalletIndexerRepairStageResult {
+    resetIndexerDatabase: boolean;
+    indexerDaemonAction: WalletRepairResult["indexerDaemonAction"];
+    indexerCompatibilityIssue: WalletRepairResult["indexerCompatibilityIssue"];
+    indexerPostRepairHealth: WalletRepairResult["indexerPostRepairHealth"];
+}

package/dist/wallet/lifecycle/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wallet/lifecycle.d.ts

@@ -1,166 +1,5 @@
-import { attachOrStartIndexerDaemon, probeIndexerDaemon } from "../bitcoind/indexer-daemon.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../bitcoind/service.js";
-import { createRpcClient } from "../bitcoind/node.js";
-import type { ManagedCoreWalletReplicaStatus, RpcListUnspentEntry } from "../bitcoind/types.js";
-import { type WalletRuntimePaths } from "./runtime.js";
-import { type WalletSecretProvider } from "./state/provider.js";
-import type { WalletStateV1 } from "./types.js";
-export interface WalletPrompter {
-    readonly isInteractive: boolean;
-    writeLine(message: string): void;
-    prompt(message: string): Promise<string>;
-    promptHidden?(message: string): Promise<string>;
-    selectOption?(options: {
-        message: string;
-        options: Array<{
-            label: string;
-            description?: string | null;
-            value: string;
-        }>;
-        initialValue?: string | null;
-        footer?: string | null;
-    }): Promise<string>;
-    clearSensitiveDisplay?(scope: "mnemonic-reveal" | "restore-mnemonic-entry"): void | Promise<void>;
-}
-export interface WalletInitializationResult {
-    passwordAction: "created" | "migrated" | "already-configured";
-    walletAction: "initialized" | "already-initialized";
-    walletRootId: string;
-    fundingAddress: string;
-    state: WalletStateV1;
-}
-export interface WalletRestoreResult {
-    passwordAction: "created" | "migrated" | "already-configured";
-    seedName?: string | null;
-    walletRootId: string;
-    fundingAddress: string;
-    state: WalletStateV1;
-    warnings?: string[];
-}
-export interface WalletDeleteResult {
-    seedName: string;
-    walletRootId: string;
-    deleted: boolean;
-}
-export interface WalletRepairResult {
-    walletRootId: string;
-    recoveredFromBackup: boolean;
-    recreatedManagedCoreWallet: boolean;
-    resetIndexerDatabase: boolean;
-    bitcoindServiceAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-service" | "restarted-compatible-service";
-    bitcoindCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch";
-    managedCoreReplicaAction: "none" | "recreated";
-    bitcoindPostRepairHealth: "ready" | "catching-up" | "starting" | "failed" | "unavailable";
-    indexerDaemonAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-daemon" | "restarted-compatible-daemon";
-    indexerCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "schema-mismatch";
-    indexerPostRepairHealth: "starting" | "catching-up" | "synced" | "failed";
-    miningPreRepairRunMode: "stopped" | "foreground" | "background";
-    miningResumeAction: "none" | "skipped-not-resumable" | "skipped-post-repair-blocked" | "resumed-background" | "resume-failed";
-    miningPostRepairRunMode: "stopped" | "background";
-    miningResumeError: string | null;
-    note: string | null;
-}
+export type { WalletInitializationResult, WalletPrompter, WalletRepairResult, } from "./lifecycle/types.js";
 export { previewResetWallet, resetWallet, type WalletResetPreview, type WalletResetResult, } from "./reset.js";
-interface WalletLifecycleRpcClient {
-    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;
-    }>;
-    unloadWallet?(walletName: string, loadOnStartup?: boolean): Promise<null>;
-    listWallets(): Promise<string[]>;
-    listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-        headers: number;
-    }>;
-}
-export declare function verifyManagedCoreWalletReplica(state: WalletStateV1, dataDir: string, dependencies?: {
-    nodeHandle?: {
-        rpc: Parameters<typeof createRpcClient>[0];
-    };
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
-}): Promise<ManagedCoreWalletReplicaStatus>;
-export declare function initializeWallet(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
-}): Promise<WalletInitializationResult>;
-export declare function showWalletMnemonic(options: {
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-}): Promise<void>;
-export declare function restoreWalletFromMnemonic(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
-}): Promise<WalletRestoreResult>;
-export declare function deleteImportedWalletSeed(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    assumeYes?: boolean;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    probeBitcoindService?: typeof probeManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
-}): Promise<WalletDeleteResult>;
-export declare function repairWallet(options: {
-    dataDir: string;
-    databasePath: string;
-    provider?: WalletSecretProvider;
-    assumeYes?: boolean;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    probeBitcoindService?: typeof probeManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
-    attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
-    probeIndexerDaemon?: typeof probeIndexerDaemon;
-    requestMiningPreemption?: typeof import("./mining/coordination.js").requestMiningGenerationPreemption;
-    startBackgroundMining?: typeof import("./mining/runner.js").startBackgroundMining;
-}): Promise<WalletRepairResult>;
+export { verifyManagedCoreWalletReplica } from "./lifecycle/managed-core.js";
+export { initializeWallet, showWalletMnemonic } from "./lifecycle/setup.js";
+export { repairWallet } from "./lifecycle/repair.js";