@cogcoin/client 1.1.5 → 1.1.7

package/dist/cli/commands/wallet-admin.js

@@ -1,17 +1,16 @@
 import { writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
 import { loadWelcomeArtText } from "../art.js";
-import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getSetupUnlockGuidanceLines, } from "../workflow-hints.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, getInitUnlockGuidanceLines, getInitNextSteps, } from "../workflow-hints.js";
 import { createOwnedLockCleanupSignalWatcher, waitForCompletionOrStop, } from "../signals.js";
 import { runSyncCommand } from "./sync.js";
-import { CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS } from "../../wallet/state/client-password.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function createCommandPrompter(context) {
     return context.createPrompter();
 }
 function getRepairWarnings(result) {
-    return result.miningResumeAction === "resume-failed"
-        ? [`Wallet repair succeeded, but background mining did not resume automatically: ${result.miningResumeError ?? "unknown error"}`]
+    return result.miningResumeAction === "skipped-background-mode-removed"
+        ? ["Background mining no longer resumes automatically after repair. Run `cogcoin mine` if you want mining resumed."]
         : [];
 }
 function getResetWarnings(result) {
@@ -20,7 +19,7 @@ function getResetWarnings(result) {
         : [];
 }
 function writeSetupUnlockGuidance(stdout) {
-    for (const line of getSetupUnlockGuidanceLines(CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS)) {
+    for (const line of getInitUnlockGuidanceLines()) {
         writeLine(stdout, line);
     }
 }
@@ -100,7 +99,8 @@ function formatResetResultText(result) {
 function isRepairMiningResumeActionOk(action) {
     return action === "none"
         || action === "skipped-not-resumable"
-        || action === "resumed-background";
+        || action === "skipped-post-repair-blocked"
+        || action === "skipped-background-mode-removed";
 }
 function buildRepairWarningEntries(result) {
     const entries = [];

package/dist/cli/context.js

@@ -13,7 +13,7 @@ import { initializeWallet, previewResetWallet, repairWallet, resetWallet, showWa
 import { resolveWalletRuntimePathsForTesting } from "../wallet/runtime.js";
 import { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
-import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, updateMiningDomainPrompt, } from "../wallet/mining/index.js";
+import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, updateMiningDomainPrompt, } from "../wallet/mining/index.js";
 import { createLazyDefaultWalletSecretProvider } from "../wallet/state/provider.js";
 import { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain, } from "../wallet/tx/index.js";
 import { createTerminalPrompter } from "./prompt.js";
@@ -93,8 +93,6 @@ export function createDefaultContext(overrides = {}) {
         inspectMiningDomainPromptState: overrides.inspectMiningDomainPromptState ?? inspectMiningDomainPromptState,
         ensureBuiltInMiningSetupIfNeeded: overrides.ensureBuiltInMiningSetupIfNeeded ?? ensureBuiltInMiningSetupIfNeeded,
         runForegroundMining: overrides.runForegroundMining ?? runForegroundMining,
-        startBackgroundMining: overrides.startBackgroundMining ?? startBackgroundMining,
-        stopBackgroundMining: overrides.stopBackgroundMining ?? stopBackgroundMining,
         setupBuiltInMining: overrides.setupBuiltInMining ?? setupBuiltInMining,
         updateMiningDomainPrompt: overrides.updateMiningDomainPrompt ?? updateMiningDomainPrompt,
         readMiningLog: overrides.readMiningLog ?? readMiningLog,

package/dist/cli/mining-json.d.ts

@@ -1,4 +1,4 @@
-import type { MiningControlPlaneView, MiningDomainPromptMutationResult, MiningRuntimeStatusV1 } from "../wallet/mining/index.js";
+import type { MiningControlPlaneView, MiningDomainPromptMutationResult } from "../wallet/mining/index.js";
 export declare function buildMineSetupData(view: MiningControlPlaneView): {
     resultType: "state-change";
     stateChange: {
@@ -8,27 +8,6 @@ export declare function buildMineSetupData(view: MiningControlPlaneView): {
     };
     state: Record<string, unknown>;
 };
-export declare function buildMineStartData(result: {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
-}): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
-export declare function buildMineStopData(snapshot: MiningRuntimeStatusV1 | null): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
 export declare function buildMinePromptData(result: MiningDomainPromptMutationResult): {
     domain: {
         name: string;

package/dist/cli/mining-json.js

@@ -35,29 +35,6 @@ export function buildMineSetupData(view) {
         after,
     });
 }
-export function buildMineStartData(result) {
-    const after = {
-        started: result.started,
-        runtime: summarizeRuntime(result.snapshot),
-    };
-    return buildStateChangeData({
-        kind: "mine-start",
-        state: after,
-        after,
-    });
-}
-export function buildMineStopData(snapshot) {
-    const after = {
-        stopped: snapshot !== null,
-        runtime: summarizeRuntime(snapshot),
-        note: snapshot?.note ?? "Background mining was not active.",
-    };
-    return buildStateChangeData({
-        kind: "mine-stop",
-        state: after,
-        after,
-    });
-}
 export function buildMinePromptData(result) {
     return {
         domain: result.domain,

package/dist/cli/output.js

@@ -330,8 +330,8 @@ export function createCliErrorPresentation(errorCode, fallbackMessage, error) {
     if (errorCode === "wallet_client_password_locked") {
         return {
             what: "Client password is locked.",
-            why: "This command needs the password-protected local wallet secret, but no active unlock session is available.",
-            next: "Run `cogcoin client unlock`, or rerun the command in an interactive terminal so Cogcoin can prompt for the client password.",
+            why: "This command needs the password-protected local wallet secret, but this process does not currently hold an unlocked client-password session.",
+            next: "Rerun the command in an interactive terminal so Cogcoin can prompt for the client password. Separate CLI invocations no longer share unlocked state.",
         };
     }
     if (errorCode === "wallet_client_password_change_requires_tty") {
@@ -341,6 +341,20 @@ export function createCliErrorPresentation(errorCode, fallbackMessage, error) {
             next: "Run `cogcoin client change-password` in an interactive terminal.",
         };
     }
+    if (errorCode === "cli_client_unlock_removed") {
+        return {
+            what: "`client unlock` was removed.",
+            why: "Cogcoin no longer shares unlocked client-password sessions across separate CLI commands.",
+            next: "Rerun password-aware commands in an interactive terminal so Cogcoin can prompt for the client password when needed.",
+        };
+    }
+    if (errorCode === "cli_client_lock_removed") {
+        return {
+            what: "`client lock` was removed.",
+            why: "Cogcoin no longer keeps reusable unlocked client-password sessions after a command exits.",
+            next: "Fresh CLI invocations start locked automatically and prompt when wallet-local secrets are needed.",
+        };
+    }
     if (errorCode === "cli_restore_removed" || errorCode === "cli_wallet_restore_removed") {
         return {
             what: "Standalone restore commands were removed.",

package/dist/cli/parse.js

@@ -282,8 +282,6 @@ export function parseCliArgs(argv) {
         || command === "sync"
         || command === "follow"
         || command === "mine"
-        || command === "mine-start"
-        || command === "mine-stop"
         || command === "mine-setup"
         || command === "mine-prompt-list"
         || command === "mine-status"

package/dist/cli/preview-json.d.ts

@@ -1,6 +1,6 @@
 import type { AnchorDomainResult, CogMutationResult, DomainAdminMutationResult, DomainMarketMutationResult, FieldMutationResult, RegisterDomainResult, ReputationMutationResult, WalletMutationFeeSummary } from "../wallet/tx/index.js";
 import type { WalletRepairResult, WalletResetPreview } from "../wallet/lifecycle.js";
-import type { MiningControlPlaneView, MiningRuntimeStatusV1 } from "../wallet/mining/index.js";
+import type { MiningControlPlaneView } from "../wallet/mining/index.js";
 export declare function buildSingleTxMutationPreviewData(options: {
     kind: string;
     localStatus: string;
@@ -317,24 +317,3 @@ export declare function buildMineSetupPreviewData(view: MiningControlPlaneView):
     };
     state: Record<string, unknown>;
 };
-export declare function buildMineStartPreviewData(result: {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
-}): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
-export declare function buildMineStopPreviewData(snapshot: MiningRuntimeStatusV1 | null): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};

package/dist/cli/preview-json.js

@@ -252,22 +252,3 @@ export function buildMineSetupPreviewData(view) {
         },
     });
 }
-export function buildMineStartPreviewData(result) {
-    return buildStateChangePreviewData({
-        kind: "mine-start",
-        state: {
-            started: result.started,
-            runtime: summarizeRuntime(result.snapshot),
-        },
-    });
-}
-export function buildMineStopPreviewData(snapshot) {
-    return buildStateChangePreviewData({
-        kind: "mine-stop",
-        state: {
-            stopped: snapshot !== null,
-            runtime: summarizeRuntime(snapshot),
-            note: snapshot?.note ?? "Background mining was not active.",
-        },
-    });
-}

package/dist/cli/types.d.ts

@@ -11,7 +11,7 @@ import type { WalletPrompter, initializeWallet, previewResetWallet, repairWallet
 import type { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
 import type { WalletSecretProvider } from "../wallet/state/provider.js";
-import type { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, updateMiningDomainPrompt } from "../wallet/mining/index.js";
+import type { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, updateMiningDomainPrompt } from "../wallet/mining/index.js";
 import type { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain } from "../wallet/tx/index.js";
 import type { CommandHandlerFamily, CommandName } from "./command-registry.js";
 export type { CommandHandlerFamily, CommandName } from "./command-registry.js";
@@ -154,8 +154,6 @@ export interface CliRunnerContext {
     inspectMiningDomainPromptState?: typeof inspectMiningDomainPromptState;
     ensureBuiltInMiningSetupIfNeeded?: typeof ensureBuiltInMiningSetupIfNeeded;
     runForegroundMining?: typeof runForegroundMining;
-    startBackgroundMining?: typeof startBackgroundMining;
-    stopBackgroundMining?: typeof stopBackgroundMining;
     setupBuiltInMining?: typeof setupBuiltInMining;
     updateMiningDomainPrompt?: typeof updateMiningDomainPrompt;
     readMiningLog?: typeof readMiningLog;

package/dist/cli/wallet-format.js

@@ -115,7 +115,7 @@ export function getRepairRecommendation(context) {
 }
 export function getClientUnlockRecommendation(context) {
     if (context.localState.unlockRequired) {
-        return "Run `cogcoin client unlock` to temporarily unlock wallet-local secrets.";
+        return "Rerun this command in an interactive terminal so Cogcoin can prompt for the client password.";
     }
     return null;
 }

package/dist/cli/workflow-hints.d.ts

@@ -3,12 +3,11 @@ export declare function formatNextStepLines(nextSteps: readonly string[]): strin
 export declare function getFundingQuickstartGuidance(): string;
 export declare function getInitNextSteps(): string[];
 export declare function getRestoreNextSteps(): string[];
-export declare function getSetupUnlockGuidanceLines(unlockSeconds: number): string[];
+export declare function getInitUnlockGuidanceLines(): string[];
 export declare function getBootstrapSyncNextStep(context: Pick<WalletReadContext, "bitcoind" | "indexer" | "nodeHealth">): string | null;
 export declare function getRegisterNextSteps(domainName: string, registerKind: "root" | "subdomain"): string[];
 export declare function getAnchorNextSteps(domainName: string): string[];
 export declare function getMineSetupNextSteps(): string[];
-export declare function getMineStopNextSteps(): string[];
 export declare function getAddressNextSteps(context: Pick<WalletReadContext, "bitcoind" | "indexer" | "nodeHealth">, address: string | null | undefined): string[];
 export declare function getIdsNextSteps(walletAddress: string | null | undefined): string[];
 export declare function getLocksNextSteps(locks: readonly WalletLockView[] | null | undefined): string[];

package/dist/cli/workflow-hints.js

@@ -13,10 +13,10 @@ export function getInitNextSteps() {
 export function getRestoreNextSteps() {
     return ["cogcoin sync", "cogcoin address"];
 }
-export function getSetupUnlockGuidanceLines(unlockSeconds) {
+export function getInitUnlockGuidanceLines() {
     return [
-        `Client unlock: active for ${unlockSeconds} seconds.`,
-        "Use `cogcoin client unlock` to lengthen this unlock window, or `cogcoin client lock` to lock immediately.",
+        "Client password reuse stays active in memory for the rest of this long-running init command, up to about 24 hours.",
+        "Future Cogcoin commands will prompt again when they need wallet-local secrets.",
     ];
 }
 function blocksSyncBootstrap(context) {
@@ -52,15 +52,12 @@ export function getRegisterNextSteps(domainName, registerKind) {
 export function getAnchorNextSteps(domainName) {
     const nextSteps = [`cogcoin show ${domainName}`];
     if (isRootDomainName(domainName)) {
-        nextSteps.push("cogcoin mine", "cogcoin mine start");
+        nextSteps.push("cogcoin mine");
     }
     return nextSteps;
 }
 export function getMineSetupNextSteps() {
-    return ["cogcoin mine", "cogcoin mine start"];
-}
-export function getMineStopNextSteps() {
-    return ["cogcoin mine log"];
+    return ["cogcoin mine"];
 }
 export function getAddressNextSteps(context, address) {
     if (address === null || address === undefined || address.length === 0) {

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

@@ -0,0 +1,5 @@
+import type { WalletAccessContext, WalletLoadedState } from "./types.js";
+export declare function isWalletSecretAccessError(error: unknown): boolean;
+export declare function mapWalletReadAccessError(error: unknown): Error;
+export declare function normalizeLoadedWalletStateIfNeeded(options: WalletAccessContext & WalletLoadedState): Promise<WalletLoadedState>;
+export declare function loadWalletStateForAccess(options: WalletAccessContext): Promise<WalletLoadedState>;

package/dist/wallet/lifecycle/access.js

@@ -0,0 +1,79 @@
+import { normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded, } from "../coin-control.js";
+import { persistNormalizedWalletDescriptorStateIfNeeded } from "../descriptor-normalization.js";
+import { normalizeMiningStateRecord } from "../mining/state.js";
+import { createWalletSecretReference } from "../state/provider.js";
+import { loadWalletState } from "../state/storage.js";
+export function isWalletSecretAccessError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.startsWith("wallet_secret_missing_")
+        || message.startsWith("wallet_secret_provider_");
+}
+export function mapWalletReadAccessError(error) {
+    if (isWalletSecretAccessError(error)) {
+        return new Error("wallet_secret_provider_unavailable");
+    }
+    return new Error("local-state-corrupt");
+}
+export async function normalizeLoadedWalletStateIfNeeded(options) {
+    let state = options.state;
+    let source = options.source;
+    if (options.dataDir !== undefined) {
+        const node = await options.attachService({
+            dataDir: options.dataDir,
+            chain: "main",
+            startHeight: 0,
+            walletRootId: state.walletRootId,
+        });
+        try {
+            const normalizedDescriptorState = await persistNormalizedWalletDescriptorStateIfNeeded({
+                state,
+                access: {
+                    provider: options.provider,
+                    secretReference: createWalletSecretReference(state.walletRootId),
+                },
+                paths: options.paths,
+                nowUnixMs: options.nowUnixMs,
+                replacePrimary: source === "backup",
+                rpc: options.rpcFactory(node.rpc),
+            });
+            state = normalizedDescriptorState.state;
+            source = normalizedDescriptorState.changed ? "primary" : source;
+            const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
+                state,
+                access: {
+                    provider: options.provider,
+                    secretReference: createWalletSecretReference(state.walletRootId),
+                },
+                paths: options.paths,
+                nowUnixMs: options.nowUnixMs,
+                replacePrimary: source === "backup",
+                rpc: options.rpcFactory(node.rpc),
+            });
+            state = reconciledCoinControl.state;
+            source = reconciledCoinControl.changed ? "primary" : source;
+        }
+        finally {
+            await node.stop?.().catch(() => undefined);
+        }
+    }
+    return {
+        state: normalizeWalletStateRecord({
+            ...state,
+            miningState: normalizeMiningStateRecord(state.miningState),
+        }),
+        source,
+    };
+}
+export async function loadWalletStateForAccess(options) {
+    const loaded = await loadWalletState({
+        primaryPath: options.paths.walletStatePath,
+        backupPath: options.paths.walletStateBackupPath,
+    }, {
+        provider: options.provider,
+    });
+    return await normalizeLoadedWalletStateIfNeeded({
+        ...options,
+        state: loaded.state,
+        source: loaded.source,
+    });
+}

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

@@ -0,0 +1,26 @@
+import { type WalletRuntimePaths } from "../runtime.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { WalletManagedCoreContext, WalletManagedCoreDependencies, WalletPrompter, WalletRepairContext, WalletRepairDependencies, WalletSetupContext, WalletSetupDependencies } from "./types.js";
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function walletStateExists(paths: WalletRuntimePaths): Promise<boolean>;
+export declare function resolveWalletManagedCoreContext(options: {
+    provider?: WalletSecretProvider;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+} & WalletManagedCoreDependencies): WalletManagedCoreContext;
+export declare function resolveWalletSetupContext(options: {
+    dataDir: string;
+    prompter: WalletPrompter;
+    provider?: WalletSecretProvider;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+} & WalletSetupDependencies): WalletSetupContext;
+export declare function resolveWalletRepairContext(options: {
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+} & WalletRepairDependencies): WalletRepairContext;
+export declare function acquireWalletControlLock(paths: WalletRuntimePaths, purpose: "wallet-init" | "wallet-show-mnemonic" | "wallet-repair"): Promise<import("../fs/lock.js").FileLockHandle>;

package/dist/wallet/lifecycle/context.js

@@ -0,0 +1,57 @@
+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 { acquireFileLock } from "../fs/lock.js";
+import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
+import { createDefaultWalletSecretProvider, } from "../state/provider.js";
+export async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function walletStateExists(paths) {
+    const [hasPrimaryState, hasBackupState] = await Promise.all([
+        pathExists(paths.walletStatePath),
+        pathExists(paths.walletStateBackupPath),
+    ]);
+    return hasPrimaryState || hasBackupState;
+}
+export function resolveWalletManagedCoreContext(options) {
+    return {
+        provider: options.provider ?? createDefaultWalletSecretProvider(),
+        paths: options.paths ?? resolveWalletRuntimePathsForTesting(),
+        nowUnixMs: options.nowUnixMs ?? Date.now(),
+        attachService: options.attachService ?? attachOrStartManagedBitcoindService,
+        rpcFactory: options.rpcFactory ?? createRpcClient,
+    };
+}
+export function resolveWalletSetupContext(options) {
+    return {
+        ...resolveWalletManagedCoreContext(options),
+        dataDir: options.dataDir,
+        prompter: options.prompter,
+    };
+}
+export function resolveWalletRepairContext(options) {
+    return {
+        ...resolveWalletManagedCoreContext(options),
+        dataDir: options.dataDir,
+        databasePath: options.databasePath,
+        assumeYes: options.assumeYes ?? false,
+        probeBitcoindService: options.probeBitcoindService ?? probeManagedBitcoindService,
+        attachIndexerDaemon: options.attachIndexerDaemon ?? attachOrStartIndexerDaemon,
+        probeIndexerDaemon: options.probeIndexerDaemon ?? probeIndexerDaemon,
+        requestMiningPreemption: options.requestMiningPreemption,
+    };
+}
+export async function acquireWalletControlLock(paths, purpose) {
+    return await acquireFileLock(paths.walletControlLockPath, {
+        purpose,
+        walletRootId: null,
+    });
+}

package/dist/wallet/lifecycle/managed-core.d.ts

@@ -4,16 +4,8 @@ import type { ManagedCoreWalletReplicaStatus } from "../../bitcoind/types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletStateV1 } from "../types.js";
-import type { WalletLifecycleRpcClient, WalletManagedCoreDependencies, WalletLifecycleResolvedContext } from "./types.js";
+import type { WalletLifecycleRpcClient, WalletManagedCoreDependencies } from "./types.js";
 export declare function sanitizeWalletName(walletRootId: string): string;
-export declare function normalizeLoadedWalletStateIfNeeded(options: WalletLifecycleResolvedContext & {
-    state: WalletStateV1;
-    source: "primary" | "backup";
-    dataDir?: string;
-} & WalletManagedCoreDependencies): Promise<{
-    state: WalletStateV1;
-    source: "primary" | "backup";
-}>;
 export declare function importDescriptorIntoManagedCoreWallet(state: WalletStateV1, provider: WalletSecretProvider, paths: WalletRuntimePaths, dataDir: string, nowUnixMs: number, attachService?: typeof attachOrStartManagedBitcoindService, rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient): Promise<WalletStateV1>;
 export declare function recreateManagedCoreWalletReplica(state: WalletStateV1, provider: WalletSecretProvider, paths: WalletRuntimePaths, dataDir: string, nowUnixMs: number, options?: WalletManagedCoreDependencies): Promise<WalletStateV1>;
 export declare function verifyManagedCoreWalletReplica(state: WalletStateV1, dataDir: string, dependencies?: WalletManagedCoreDependencies & {

package/dist/wallet/lifecycle/managed-core.js

@@ -1,75 +1,15 @@
-import { access, constants, rename } from "node:fs/promises";
+import { rename } from "node:fs/promises";
 import { join } from "node:path";
 import { attachOrStartManagedBitcoindService, createManagedWalletReplica } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
-import { persistWalletCoinControlStateIfNeeded, normalizeWalletStateRecord } from "../coin-control.js";
-import { persistNormalizedWalletDescriptorStateIfNeeded, resolveNormalizedWalletDescriptorState, } from "../descriptor-normalization.js";
-import { normalizeMiningStateRecord } from "../mining/state.js";
+import { resolveNormalizedWalletDescriptorState, } from "../descriptor-normalization.js";
 import { createWalletSecretReference } from "../state/provider.js";
 import { saveWalletState } from "../state/storage.js";
 import { withUnlockedManagedCoreWallet } from "../managed-core-wallet.js";
+import { pathExists } from "./context.js";
 export function sanitizeWalletName(walletRootId) {
     return `cogcoin-${walletRootId}`.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 63);
 }
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function normalizeLoadedWalletStateIfNeeded(options) {
-    let state = options.state;
-    let source = options.source;
-    if (options.dataDir !== undefined) {
-        const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
-            dataDir: options.dataDir,
-            chain: "main",
-            startHeight: 0,
-            walletRootId: state.walletRootId,
-        });
-        try {
-            const normalized = await persistNormalizedWalletDescriptorStateIfNeeded({
-                state,
-                access: {
-                    provider: options.provider,
-                    secretReference: createWalletSecretReference(state.walletRootId),
-                },
-                paths: options.paths,
-                nowUnixMs: options.nowUnixMs,
-                replacePrimary: options.source === "backup",
-                rpc: (options.rpcFactory ?? createRpcClient)(node.rpc),
-            });
-            state = normalized.state;
-            source = normalized.changed ? "primary" : options.source;
-            const coinControl = await persistWalletCoinControlStateIfNeeded({
-                state,
-                access: {
-                    provider: options.provider,
-                    secretReference: createWalletSecretReference(state.walletRootId),
-                },
-                paths: options.paths,
-                nowUnixMs: options.nowUnixMs,
-                replacePrimary: source === "backup",
-                rpc: createRpcClient(node.rpc),
-            });
-            state = coinControl.state;
-            source = coinControl.changed ? "primary" : source;
-        }
-        finally {
-            await node.stop?.().catch(() => undefined);
-        }
-    }
-    return {
-        state: normalizeWalletStateRecord({
-            ...state,
-            miningState: normalizeMiningStateRecord(state.miningState),
-        }),
-        source,
-    };
-}
 export async function importDescriptorIntoManagedCoreWallet(state, provider, paths, dataDir, nowUnixMs, attachService = attachOrStartManagedBitcoindService, rpcFactory = createRpcClient) {
     const node = await attachService({
         dataDir,

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

@@ -0,0 +1,10 @@
+import type { ManagedServicePaths } from "../../bitcoind/service-paths.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletBitcoindRepairStageResult, WalletRepairContext } from "./types.js";
+export declare function repairManagedBitcoindStage(options: {
+    context: WalletRepairContext;
+    servicePaths: ManagedServicePaths;
+    state: WalletStateV1;
+    recoveredFromBackup: boolean;
+    repairStateNeedsPersist: boolean;
+}): Promise<WalletBitcoindRepairStageResult>;