@cogcoin/client 1.1.5 → 1.1.7

package/dist/bitcoind/service.d.ts

@@ -1,5 +1,7 @@
+import type { ManagedBitcoindServiceProbeResult } from "./managed-runtime/types.js";
 import { resolveManagedServicePaths } from "./service-paths.js";
 import type { InternalManagedBitcoindOptions, ManagedBitcoindObservedStatus, ManagedBitcoindRuntimeConfig, ManagedBitcoindNodeHandle, ManagedCoreWalletReplicaStatus } from "./types.js";
+export type { ManagedBitcoindServiceCompatibility, ManagedBitcoindServiceProbeResult, } from "./managed-runtime/types.js";
 export declare function resolveManagedBitcoindDbcacheMiB(totalRamBytes: number): number;
 interface ManagedWalletReplicaRpc {
     listWallets(): Promise<string[]>;
@@ -26,12 +28,6 @@ type ManagedBitcoindServiceOptions = Pick<InternalManagedBitcoindOptions, "dataD
     getblockArchiveSha256?: string | null;
     serviceLifetime?: "persistent" | "ephemeral";
 };
-export type ManagedBitcoindServiceCompatibility = "compatible" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch" | "unreachable" | "protocol-error";
-export interface ManagedBitcoindServiceProbeResult {
-    compatibility: ManagedBitcoindServiceCompatibility;
-    status: ManagedBitcoindObservedStatus | null;
-    error: string | null;
-}
 export interface ManagedBitcoindServiceStopResult {
     status: "stopped" | "not-running";
     walletRootId: string;
@@ -66,4 +62,3 @@ export declare function shutdownManagedBitcoindServiceForTesting(options: {
     walletRootId?: string;
     shutdownTimeoutMs?: number;
 }): Promise<void>;
-export {};

package/dist/bitcoind/service.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
-import { access, constants, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
+import { totalmem } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import net from "node:net";
@@ -9,6 +10,10 @@ import { acquireFileLock, FileLockBusyError } from "../wallet/fs/lock.js";
 import { writeFileAtomic } from "../wallet/fs/atomic.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
 import { stopIndexerDaemonServiceWithLockHeld } from "./indexer-daemon.js";
+import { mapManagedBitcoindRuntimeProbeFailure, mapManagedBitcoindValidationError, validateManagedBitcoindObservedStatus, } from "./managed-runtime/bitcoind-policy.js";
+import { listManagedBitcoindStatusCandidates, readManagedBitcoindObservedStatus, } from "./managed-runtime/bitcoind-status.js";
+import { attachOrStartManagedBitcoindRuntime, probeManagedBitcoindRuntime, } from "./managed-runtime/bitcoind-runtime.js";
+import { readJsonFileIfPresent } from "./managed-runtime/status.js";
 import { createRpcClient, validateNodeConfigForTesting } from "./node.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
 import { DEFAULT_MANAGED_BITCOIND_FOLLOW_POLL_INTERVAL_MS, MANAGED_BITCOIND_SERVICE_API_VERSION as MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE, } from "./types.js";
@@ -17,14 +22,31 @@ const LOCAL_HOST = "127.0.0.1";
 const SUPPORTED_BITCOIND_VERSION = "30.2.0";
 const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 15_000;
-const DEFAULT_DBCACHE_MIB = 2048;
+const DEFAULT_DBCACHE_MIB = 450;
 const claimedUninitializedRuntimeKeys = new Set();
+const GIB = 1024 ** 3;
 export function resolveManagedBitcoindDbcacheMiB(totalRamBytes) {
-    void totalRamBytes;
-    return DEFAULT_DBCACHE_MIB;
+    if (!Number.isFinite(totalRamBytes) || totalRamBytes <= 0) {
+        return DEFAULT_DBCACHE_MIB;
+    }
+    if (totalRamBytes < 8 * GIB) {
+        return 450;
+    }
+    if (totalRamBytes < 16 * GIB) {
+        return 768;
+    }
+    if (totalRamBytes < 32 * GIB) {
+        return 1024;
+    }
+    return 2048;
 }
 function detectManagedBitcoindDbcacheMiB() {
-    return DEFAULT_DBCACHE_MIB;
+    try {
+        return resolveManagedBitcoindDbcacheMiB(totalmem());
+    }
+    catch {
+        return DEFAULT_DBCACHE_MIB;
+    }
 }
 function sleep(ms) {
     return new Promise((resolve) => {
@@ -58,53 +80,6 @@ async function acquireFileLockWithRetry(lockPath, metadata, timeoutMs) {
 function getWalletReplicaName(walletRootId) {
     return `cogcoin-${walletRootId}`.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 63);
 }
-async function readJsonFile(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-async function listManagedBitcoindStatusCandidates(options) {
-    const candidates = new Map();
-    const addCandidate = async (statusPath, allowDataDirMismatch = false) => {
-        const status = await readJsonFile(statusPath);
-        if (status === null) {
-            return;
-        }
-        if (!allowDataDirMismatch && status.dataDir !== options.dataDir) {
-            return;
-        }
-        candidates.set(statusPath, status);
-    };
-    await addCandidate(options.expectedStatusPath, true);
-    try {
-        const entries = await readdir(options.runtimeRoot, {
-            withFileTypes: true,
-        });
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            const statusPath = join(options.runtimeRoot, entry.name, "bitcoind-status.json");
-            if (statusPath === options.expectedStatusPath) {
-                continue;
-            }
-            await addCandidate(statusPath);
-        }
-    }
-    catch {
-        // Missing runtime roots are handled by returning no candidates.
-    }
-    return [...candidates.entries()].map(([statusPath, status]) => ({
-        statusPath,
-        status,
-    }));
-}
 async function allocatePort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -207,38 +182,6 @@ async function waitForRpcReady(rpc, cookieFile, expectedChain, timeoutMs) {
     }
     throw lastError instanceof Error ? lastError : new Error("bitcoind_rpc_timeout");
 }
-function validateManagedBitcoindStatus(status, options, runtimeRoot) {
-    const legacyRuntimeRoot = join(resolveManagedServicePaths(options.dataDir ?? "", options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID).runtimeRoot, status.walletRootId);
-    if (status.serviceApiVersion !== MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE) {
-        throw new Error("managed_bitcoind_service_version_mismatch");
-    }
-    if (status.chain !== options.chain
-        || status.dataDir !== (options.dataDir ?? "")
-        || (status.runtimeRoot !== runtimeRoot && status.runtimeRoot !== legacyRuntimeRoot)) {
-        throw new Error("managed_bitcoind_runtime_mismatch");
-    }
-}
-function isRuntimeMismatchError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return error.message.startsWith("bitcoind_chain_expected_")
-        || error.message === "managed_bitcoind_runtime_mismatch";
-}
-function isUnreachableManagedBitcoindError(error) {
-    if (error instanceof Error) {
-        if ("code" in error) {
-            const code = error.code;
-            return code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET";
-        }
-        return error.message === "bitcoind_cookie_timeout"
-            || error.message.includes("cookie file is unavailable")
-            || error.message.includes("ECONNREFUSED")
-            || error.message.includes("ECONNRESET")
-            || error.message.includes("socket hang up");
-    }
-    return false;
-}
 function createBitcoindServiceStatus(options) {
     return {
         serviceApiVersion: MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE,
@@ -264,27 +207,16 @@ function createBitcoindServiceStatus(options) {
         lastError: options.lastError,
     };
 }
-function mapManagedBitcoindValidationError(error) {
-    return {
-        compatibility: error instanceof Error
-            ? error.message === "managed_bitcoind_service_version_mismatch"
-                ? "service-version-mismatch"
-                : "runtime-mismatch"
-            : "protocol-error",
-        status: null,
-        error: error instanceof Error ? error.message : "managed_bitcoind_protocol_error",
-    };
-}
 async function probeManagedBitcoindStatusCandidate(status, options, runtimeRoot) {
     try {
-        validateManagedBitcoindStatus(status, options, runtimeRoot);
+        validateManagedBitcoindObservedStatus(status, {
+            chain: options.chain,
+            dataDir: options.dataDir ?? "",
+            runtimeRoot,
+        });
     }
     catch (error) {
-        const mapped = mapManagedBitcoindValidationError(error);
-        return {
-            ...mapped,
-            status,
-        };
+        return mapManagedBitcoindValidationError(error, status);
     }
     const rpc = createRpcClient(status.rpc);
     try {
@@ -297,30 +229,12 @@ async function probeManagedBitcoindStatusCandidate(status, options, runtimeRoot)
         };
     }
     catch (error) {
-        if (isRuntimeMismatchError(error)) {
-            return {
-                compatibility: "runtime-mismatch",
-                status,
-                error: "managed_bitcoind_runtime_mismatch",
-            };
-        }
-        if (isUnreachableManagedBitcoindError(error)) {
-            return {
-                compatibility: "unreachable",
-                status,
-                error: null,
-            };
-        }
-        return {
-            compatibility: "protocol-error",
-            status,
-            error: "managed_bitcoind_protocol_error",
-        };
+        return mapManagedBitcoindRuntimeProbeFailure(error, status);
     }
 }
 async function resolveRuntimeConfig(statusPath, configPath, options) {
-    const previousStatus = await readJsonFile(statusPath);
-    const previousConfig = await readJsonFile(configPath);
+    const previousStatus = await readJsonFileIfPresent(statusPath);
+    const previousConfig = await readJsonFileIfPresent(configPath);
     const reserved = new Set();
     const rpcPort = options.rpcPort
         ?? previousStatus?.rpc.port
@@ -545,7 +459,7 @@ async function clearManagedBitcoindRuntimeArtifacts(paths) {
 export async function stopManagedBitcoindServiceWithLockHeld(options) {
     const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
     const paths = options.paths ?? resolveManagedServicePaths(options.dataDir, walletRootId);
-    const status = await readJsonFile(paths.bitcoindStatusPath);
+    const status = await readJsonFileIfPresent(paths.bitcoindStatusPath);
     const processId = status?.processId ?? null;
     if (status === null || processId === null || !await isProcessAlive(processId)) {
         await clearManagedBitcoindRuntimeArtifacts(paths);
@@ -716,44 +630,19 @@ async function tryAttachExistingManagedBitcoindService(options) {
     const refreshed = await refreshManagedBitcoindStatus(probe.status, paths, options);
     return createNodeHandle(refreshed, paths, options, "attached");
 }
-async function waitForManagedBitcoindService(options, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const attached = await tryAttachExistingManagedBitcoindService(options).catch(() => null);
-        if (attached !== null) {
-            return attached;
-        }
-        await sleep(250);
-    }
-    throw new Error("managed_bitcoind_service_start_timeout");
-}
 export async function probeManagedBitcoindService(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir ?? "", walletRootId);
-    const candidates = await listManagedBitcoindStatusCandidates({
+    const resolvedOptions = {
+        ...options,
         dataDir: options.dataDir ?? "",
-        runtimeRoot: paths.runtimeRoot,
-        expectedStatusPath: paths.bitcoindStatusPath,
-    });
-    const expectedCandidate = candidates.find((candidate) => candidate.statusPath === paths.bitcoindStatusPath) ?? null;
-    for (const candidate of candidates) {
-        if (!await isProcessAlive(candidate.status.processId)) {
-            continue;
-        }
-        return probeManagedBitcoindStatusCandidate(candidate.status, options, paths.walletRuntimeRoot);
-    }
-    if (expectedCandidate !== null) {
-        return {
-            compatibility: "unreachable",
-            status: expectedCandidate.status,
-            error: null,
-        };
-    }
-    return {
-        compatibility: "unreachable",
-        status: candidates[0]?.status ?? null,
-        error: null,
+        walletRootId: options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
+        startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
     };
+    return probeManagedBitcoindRuntime(resolvedOptions, {
+        getPaths: (runtimeOptions) => resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
+        listStatusCandidates: listManagedBitcoindStatusCandidates,
+        isProcessAlive,
+        probeStatusCandidate: probeManagedBitcoindStatusCandidate,
+    });
 }
 export async function attachOrStartManagedBitcoindService(options) {
     const resolvedOptions = {
@@ -768,38 +657,27 @@ export async function attachOrStartManagedBitcoindService(options) {
         walletRootId: resolvedOptions.walletRootId,
         shutdownTimeoutMs: resolvedOptions.shutdownTimeoutMs,
     }, async () => {
-        const existingProbe = await probeManagedBitcoindService(resolvedOptions);
-        if (existingProbe.compatibility === "compatible") {
-            const existing = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-            if (existing !== null) {
-                return existing;
-            }
-        }
-        if (existingProbe.compatibility !== "unreachable") {
-            throw new Error(existingProbe.error ?? "managed_bitcoind_protocol_error");
-        }
-        const paths = resolveManagedServicePaths(resolvedOptions.dataDir ?? "", resolvedOptions.walletRootId);
-        try {
-            const lock = await acquireFileLock(paths.bitcoindLockPath, {
+        return attachOrStartManagedBitcoindRuntime({
+            ...resolvedOptions,
+            dataDir: resolvedOptions.dataDir ?? "",
+            walletRootId: resolvedOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
+            startupTimeoutMs,
+        }, {
+            getPaths: (runtimeOptions) => resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
+            listStatusCandidates: listManagedBitcoindStatusCandidates,
+            isProcessAlive,
+            probeStatusCandidate: probeManagedBitcoindStatusCandidate,
+            attachExisting: tryAttachExistingManagedBitcoindService,
+            acquireStartLock: async (runtimeOptions, paths) => acquireFileLock(paths.bitcoindLockPath, {
                 purpose: "managed-bitcoind-start",
-                walletRootId: resolvedOptions.walletRootId,
-                dataDir: resolvedOptions.dataDir,
-            });
-            try {
-                const liveProbe = await probeManagedBitcoindService(resolvedOptions);
-                if (liveProbe.compatibility === "compatible") {
-                    const reattached = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-                    if (reattached !== null) {
-                        return reattached;
-                    }
-                }
-                if (liveProbe.compatibility !== "unreachable") {
-                    throw new Error(liveProbe.error ?? "managed_bitcoind_protocol_error");
-                }
+                walletRootId: runtimeOptions.walletRootId,
+                dataDir: runtimeOptions.dataDir,
+            }),
+            startService: async (runtimeOptions, paths) => {
                 const bitcoindPath = await getBitcoindPath();
                 await verifyBitcoindVersion(bitcoindPath);
                 const binaryVersion = SUPPORTED_BITCOIND_VERSION;
-                await mkdir(resolvedOptions.dataDir ?? "", { recursive: true });
+                await mkdir(runtimeOptions.dataDir, { recursive: true });
                 const startManagedProcess = async (startOptions) => {
                     const runtimeConfig = await resolveRuntimeConfig(paths.bitcoindStatusPath, paths.bitcoindRuntimeConfigPath, startOptions);
                     await writeBitcoinConf(paths.bitcoinConfPath, startOptions, runtimeConfig);
@@ -841,16 +719,15 @@ export async function attachOrStartManagedBitcoindService(options) {
                         throw error;
                     }
                     const nowUnixMs = Date.now();
-                    const walletRootId = startOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-                    const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, walletRootId, startOptions.dataDir ?? "");
+                    const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, startOptions.walletRootId, startOptions.dataDir);
                     return createBitcoindServiceStatus({
                         binaryVersion,
                         serviceInstanceId: randomBytes(16).toString("hex"),
                         state: "ready",
                         processId: child.pid ?? null,
-                        walletRootId,
+                        walletRootId: startOptions.walletRootId,
                         chain: startOptions.chain,
-                        dataDir: startOptions.dataDir ?? "",
+                        dataDir: startOptions.dataDir,
                         runtimeRoot: paths.walletRuntimeRoot,
                         startHeight: startOptions.startHeight,
                         rpc: rpcConfig,
@@ -866,32 +743,25 @@ export async function attachOrStartManagedBitcoindService(options) {
                 };
                 let status;
                 try {
-                    status = await startManagedProcess(resolvedOptions);
+                    status = await startManagedProcess(runtimeOptions);
                 }
                 catch (error) {
-                    if (resolvedOptions.getblockArchivePath === undefined || resolvedOptions.getblockArchivePath === null) {
+                    if (runtimeOptions.getblockArchivePath === undefined || runtimeOptions.getblockArchivePath === null) {
                         throw error;
                     }
                     status = await startManagedProcess({
-                        ...resolvedOptions,
+                        ...runtimeOptions,
                         getblockArchivePath: null,
                         getblockArchiveEndHeight: null,
                         getblockArchiveSha256: null,
                     });
                 }
                 await writeBitcoindStatus(paths, status);
-                return createNodeHandle(status, paths, resolvedOptions, "started");
-            }
-            finally {
-                await lock.release();
-            }
-        }
-        catch (error) {
-            if (error instanceof FileLockBusyError) {
-                return waitForManagedBitcoindService(resolvedOptions, startupTimeoutMs);
-            }
-            throw error;
-        }
+                return createNodeHandle(status, resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId), runtimeOptions, "started");
+            },
+            isLockBusyError: (error) => error instanceof FileLockBusyError,
+            sleep,
+        });
     });
 }
 export async function stopManagedBitcoindService(options) {
@@ -914,8 +784,10 @@ export async function stopManagedBitcoindService(options) {
     }
 }
 export async function readManagedBitcoindServiceStatusForTesting(dataDir, walletRootId = UNINITIALIZED_WALLET_ROOT_ID) {
-    const paths = resolveManagedServicePaths(dataDir, walletRootId);
-    return readJsonFile(paths.bitcoindStatusPath);
+    return readManagedBitcoindObservedStatus({
+        dataDir,
+        walletRootId,
+    });
 }
 export async function shutdownManagedBitcoindServiceForTesting(options) {
     await stopManagedBitcoindService({

package/dist/cli/command-registry.d.ts

@@ -1,5 +1,5 @@
 export type CommandHandlerFamily = "status" | "update" | "sync" | "follow" | "client-admin" | "service-runtime" | "wallet-admin" | "wallet-read" | "wallet-mutation" | "mining-admin" | "mining-runtime" | "mining-read";
-export type CommandName = "init" | "reset" | "repair" | "update" | "sync" | "status" | "client-lock" | "client-change-password" | "client-unlock" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "bitcoin-transfer" | "indexer-start" | "indexer-stop" | "indexer-status" | "anchor" | "register" | "transfer" | "sell" | "unsell" | "buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "fields" | "field" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "mine" | "mine-start" | "mine-stop" | "mine-setup" | "mine-prompt" | "mine-prompt-list" | "mine-status" | "mine-log" | "wallet-show-mnemonic" | "wallet-status" | "address" | "ids" | "balance" | "locks" | "domains" | "show";
+export type CommandName = "init" | "reset" | "repair" | "update" | "sync" | "status" | "client-change-password" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "bitcoin-transfer" | "indexer-start" | "indexer-stop" | "indexer-status" | "anchor" | "register" | "transfer" | "sell" | "unsell" | "buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "fields" | "field" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "mine" | "mine-setup" | "mine-prompt" | "mine-prompt-list" | "mine-status" | "mine-log" | "wallet-show-mnemonic" | "wallet-status" | "address" | "ids" | "balance" | "locks" | "domains" | "show";
 type AliasMatchMode = "always" | "requires-arg" | "end-or-flag";
 interface HelpEntry {
     usage: string;

package/dist/cli/command-registry.js

@@ -31,38 +31,6 @@ const commandSpecs = [
             return "cogcoin update";
         },
     },
-    {
-        id: "client-unlock",
-        handlerFamily: "client-admin",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["client", "unlock"] }],
-        helpEntries: [
-            {
-                usage: "client unlock",
-                description: "Unlock password-protected local wallet secrets for a limited time",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin client unlock";
-        },
-    },
-    {
-        id: "client-lock",
-        handlerFamily: "client-admin",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["client", "lock"] }],
-        helpEntries: [
-            {
-                usage: "client lock",
-                description: "Flush the cached client password unlock session",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin client lock";
-        },
-    },
     {
         id: "client-change-password",
         handlerFamily: "client-admin",
@@ -308,38 +276,6 @@ const commandSpecs = [
             return "cogcoin mine";
         },
     },
-    {
-        id: "mine-start",
-        handlerFamily: "mining-runtime",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["mine", "start"] }],
-        helpEntries: [
-            {
-                usage: "mine start",
-                description: "Start the miner as a background worker",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin mine start";
-        },
-    },
-    {
-        id: "mine-stop",
-        handlerFamily: "mining-runtime",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["mine", "stop"] }],
-        helpEntries: [
-            {
-                usage: "mine stop",
-                description: "Stop the active background miner",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin mine stop";
-        },
-    },
     {
         id: "mine-setup",
         handlerFamily: "mining-admin",
@@ -949,6 +885,8 @@ const commandSpecs = [
     },
 ];
 const removedPathSpecs = [
+    { tokens: ["client", "unlock"], errorCode: "cli_client_unlock_removed" },
+    { tokens: ["client", "lock"], errorCode: "cli_client_lock_removed" },
     { tokens: ["restore"], errorCode: "cli_restore_removed" },
     { tokens: ["wallet", "delete"], errorCode: "cli_wallet_delete_removed" },
     { tokens: ["wallet", "restore"], errorCode: "cli_wallet_restore_removed" },

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

@@ -1,30 +1,15 @@
 import { writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
-import { changeClientPassword, lockClientPassword, unlockClientPassword, } from "../../wallet/state/provider.js";
+import { changeClientPassword, } from "../../wallet/state/provider.js";
 function createCommandPrompter(context) {
     return context.createPrompter();
 }
 export async function runClientAdminCommand(parsed, context) {
     try {
-        if (parsed.command === "client-lock") {
-            await lockClientPassword(context.walletSecretProvider);
-            writeLine(context.stdout, "Client locked.");
-            return 0;
-        }
-        if (parsed.command === "client-unlock") {
-            const prompter = createCommandPrompter(context);
-            const status = await unlockClientPassword(context.walletSecretProvider, prompter);
-            writeLine(context.stdout, status.unlockUntilUnixMs === null
-                ? "Client unlocked."
-                : `Client unlocked until ${new Date(status.unlockUntilUnixMs).toISOString()}.`);
-            return 0;
-        }
         if (parsed.command === "client-change-password") {
             const prompter = createCommandPrompter(context);
-            const status = await changeClientPassword(context.walletSecretProvider, prompter);
-            writeLine(context.stdout, status.unlockUntilUnixMs === null
-                ? "Client password changed."
-                : `Client password changed. Client unlocked until ${new Date(status.unlockUntilUnixMs).toISOString()}.`);
+            await changeClientPassword(context.walletSecretProvider, prompter);
+            writeLine(context.stdout, "Client password changed.");
             return 0;
         }
         writeLine(context.stderr, `client admin command not implemented: ${parsed.command}`);

package/dist/cli/commands/mining-runtime.js

@@ -1,12 +1,13 @@
 import { dirname } from "node:path";
 import { DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap.js";
 import { createEmptyMiningFollowVisualizerState, MiningFollowVisualizer, } from "../../wallet/mining/visualizer.js";
+import { createMiningStopRequestedError } from "../../wallet/mining/stop.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
+import { bindClientPasswordPromptSessionPolicy } from "../../wallet/state/client-password/session-policy.js";
 import { ManagedIndexerProgressObserver, assertManagedIndexerStatusRecoverable, isManagedIndexerCaughtUp, pollManagedIndexerUntilCaughtUp, } from "../managed-indexer-observer.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
-import { formatNextStepLines, getMineStopNextSteps, } from "../workflow-hints.js";
 import { createCloseSignalWatcher, waitForCompletionOrStop } from "../signals.js";
 import { createSyncProgressReporter } from "../sync-progress.js";
 import { PASSIVE_UPDATE_CHECK_TIMEOUT_MS, applyUpdateCheckResult, compareSemver, createEmptyUpdateCheckCache, fetchLatestPublishedVersion, isUpdateCheckDisabled, loadUpdateCheckCache, persistUpdateCheckCache, shouldRefreshUpdateCheck, } from "../update-service.js";
@@ -317,7 +318,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const packageVersion = await context.readPackageVersion();
         const runtimePaths = context.resolveWalletRuntimePaths();
         if (parsed.command === "mine") {
-            const prompter = context.createPrompter();
+            const prompter = bindClientPasswordPromptSessionPolicy(context.createPrompter(), "mining-indefinite");
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
             const ttyProgressActive = usesTtyProgress(parsed.progressOutput, context.stderr);
             await ensureMiningProviderSetup({
@@ -368,7 +369,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     : false;
                 abortController = new AbortController();
                 onStop = () => {
-                    abortController?.abort();
+                    abortController?.abort(createMiningStopRequestedError());
                 };
                 context.signalSource.on("SIGINT", onStop);
                 context.signalSource.on("SIGTERM", onStop);
@@ -397,63 +398,6 @@ export async function runMiningRuntimeCommand(parsed, context) {
             }
             return 0;
         }
-        if (parsed.command === "mine-start") {
-            const prompter = createCommandPrompter(context);
-            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
-            await ensureMiningProviderSetup({
-                context,
-                provider,
-                prompter,
-                runtimePaths,
-            });
-            const preflightCode = await syncManagedMiningReadiness({
-                parsed,
-                context,
-                dataDir,
-                databasePath: dbPath,
-                expectedBinaryVersion: packageVersion,
-                provider,
-                runtimePaths,
-            });
-            if (preflightCode !== null) {
-                return preflightCode;
-            }
-            const result = await context.startBackgroundMining({
-                dataDir,
-                databasePath: dbPath,
-                provider,
-                prompter,
-                builtInSetupEnsured: true,
-                paths: runtimePaths,
-            });
-            if (!result.started) {
-                writeLine(context.stdout, "Background mining is already active.");
-                if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
-                    writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
-                }
-                return 0;
-            }
-            writeLine(context.stdout, "Started background mining.");
-            if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
-                writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
-            }
-            return 0;
-        }
-        if (parsed.command === "mine-stop") {
-            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter());
-            const snapshot = await context.stopBackgroundMining({
-                dataDir,
-                databasePath: dbPath,
-                provider,
-                paths: runtimePaths,
-            });
-            const nextSteps = getMineStopNextSteps();
-            writeLine(context.stdout, snapshot?.note ?? "Background mining was not active.");
-            for (const line of formatNextStepLines(nextSteps)) {
-                writeLine(context.stdout, line);
-            }
-            return 0;
-        }
         writeLine(context.stderr, `mining runtime command not implemented: ${parsed.command}`);
         return 1;
     }