@cogcoin/client 1.1.6 → 1.1.8

package/dist/wallet/mining/index.d.ts

@@ -1,7 +1,7 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runForegroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1, MiningSentenceGenerationResponseV1, } from "./sentence-protocol.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

package/dist/wallet/mining/index.js

@@ -1,6 +1,6 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runForegroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

package/dist/wallet/mining/publish.d.ts

@@ -14,6 +14,7 @@ export declare class MiningPublishRejectedError extends Error {
 }
 export declare function createStaleMiningCandidateWaitingNote(): string;
 export declare function createRetryableMiningPublishWaitingNote(): string;
+export declare function createManagedCoreWalletRelockRetryWaitingNote(): string;
 export declare function createInsufficientFundsMiningPublishWaitingNote(): string;
 export declare function createInsufficientFundsMiningPublishErrorMessage(): string;
 export declare function resolveMiningConflictOutpoint(options: {
@@ -56,6 +57,7 @@ export declare function publishCandidateOnce(options: {
     rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     runId: string | null;
     appendEventFn?: AppendMiningEventFn;
+    throwIfStopping?: () => void;
 }): Promise<{
     state: WalletStateV1;
     txid: string | null;
@@ -75,5 +77,6 @@ export declare function publishCandidate(options: {
     runId: string | null;
     publishAttempt?: typeof publishCandidateOnce;
     appendEventFn: AppendMiningEventFn;
+    throwIfStopping?: () => void;
 }): Promise<MiningPublishOutcome>;
 export {};

package/dist/wallet/mining/publish.js

@@ -22,12 +22,21 @@ export class MiningPublishRejectedError extends Error {
         this.revertedState = revertedState;
     }
 }
+class ManagedCoreWalletRelockPendingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ManagedCoreWalletRelockPendingError";
+    }
+}
 export function createStaleMiningCandidateWaitingNote() {
     return "Mining candidate changed before broadcast: the selected root domain is no longer locally mineable. Skipping this tip and waiting for the next block.";
 }
 export function createRetryableMiningPublishWaitingNote() {
     return "Selected mining candidate did not reach mempool and will be retried on the current tip with refreshed wallet state.";
 }
+export function createManagedCoreWalletRelockRetryWaitingNote() {
+    return "Mining temporarily lost the managed Bitcoin wallet unlock and is retrying.";
+}
 export function createInsufficientFundsMiningPublishWaitingNote() {
     return "Insufficient BTC to mine.";
 }
@@ -114,6 +123,8 @@ async function buildMiningTransaction(options) {
         mempoolRejectPrefix: "wallet_mining_mempool_rejected",
         feeRate: options.plan.feeRateSatVb,
         availableFundingMinConf: MINING_FUNDING_MIN_CONF,
+        recoverManagedCoreWalletLockedOnce: options.recoverManagedCoreWalletLockedOnce,
+        onManagedCoreWalletLockedRecoveryOutcome: options.onManagedCoreWalletLockedRecoveryOutcome,
     });
 }
 export async function probeMiningFundingAvailability(options) {
@@ -301,6 +312,7 @@ export async function publishCandidateOnce(options) {
         startHeight: 0,
         walletRootId: options.readContext.localState.state.walletRootId,
     });
+    options.throwIfStopping?.();
     const rpc = options.rpcFactory(service.rpc);
     let state = (await reconcileLiveMiningState({
         state: options.readContext.localState.state,
@@ -309,7 +321,9 @@ export async function publishCandidateOnce(options) {
         nodeBestHeight: options.readContext.nodeStatus?.nodeBestHeight ?? null,
         snapshotState: options.readContext.snapshot.state,
     })).state;
+    options.throwIfStopping?.();
     const allUtxos = await rpc.listUnspent(state.managedCoreWallet.walletName, MINING_FUNDING_MIN_CONF);
+    options.throwIfStopping?.();
     const conflictOutpoint = resolveMiningConflictOutpoint({
         state,
         allUtxos,
@@ -330,6 +344,7 @@ export async function publishCandidateOnce(options) {
     const feeSelection = await resolveWalletMutationFeeSelection({
         rpc,
     });
+    options.throwIfStopping?.();
     const nextFeeRate = feeSelection.feeRateSatVb;
     const plan = createMiningPlan({
         state,
@@ -338,12 +353,40 @@ export async function publishCandidateOnce(options) {
         allUtxos,
         feeRateSatVb: nextFeeRate,
     });
-    const built = await buildMiningTransaction({
-        rpc,
-        walletName: state.managedCoreWallet.walletName,
-        state,
-        plan,
-    });
+    let managedCoreWalletRelockOutcome = null;
+    let built;
+    try {
+        built = await buildMiningTransaction({
+            rpc,
+            walletName: state.managedCoreWallet.walletName,
+            state,
+            plan,
+            recoverManagedCoreWalletLockedOnce: true,
+            onManagedCoreWalletLockedRecoveryOutcome: (outcome) => {
+                managedCoreWalletRelockOutcome = outcome;
+            },
+        });
+    }
+    catch (error) {
+        if (managedCoreWalletRelockOutcome === "still-locked" && error instanceof Error) {
+            throw new ManagedCoreWalletRelockPendingError(error.message);
+        }
+        throw error;
+    }
+    options.throwIfStopping?.();
+    if (managedCoreWalletRelockOutcome === "recovered" && appendEventFn !== undefined) {
+        await appendEventFn(options.paths, createMiningEventRecord("managed-core-wallet-relock-recovered", "Managed Bitcoin Core wallet relocked during signing and was recovered automatically.", {
+            level: "warn",
+            runId: options.runId,
+            targetBlockHeight: options.candidate.targetBlockHeight,
+            referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
+            domainId: options.candidate.domainId,
+            domainName: options.candidate.domainName,
+            feeRateSatVb: nextFeeRate,
+            score: options.candidate.canonicalBlend.toString(),
+            reason: "managed-core-wallet-locked",
+        }));
+    }
     const intentFingerprintHex = computeIntentFingerprint(state, options.candidate);
     state = defaultMiningStatePatch(state, {
         state: "live",
@@ -375,8 +418,10 @@ export async function publishCandidateOnce(options) {
         provider: options.provider,
         paths: options.paths,
     });
+    options.throwIfStopping?.();
     try {
         await rpc.sendRawTransaction(built.rawHex);
+        options.throwIfStopping?.();
     }
     catch (error) {
         if (isAlreadyAcceptedError(error)) {
@@ -521,6 +566,7 @@ export async function publishCandidate(options) {
             candidate: null,
         };
     };
+    options.throwIfStopping?.();
     const lockedReadContext = await options.openReadContext({
         dataDir: options.dataDir,
         databasePath: options.databasePath,
@@ -529,6 +575,7 @@ export async function publishCandidate(options) {
         paths: options.paths,
     });
     try {
+        options.throwIfStopping?.();
         if (lockedReadContext.localState.availability !== "ready"
             || lockedReadContext.localState.state === null
             || lockedReadContext.snapshot === null
@@ -541,6 +588,7 @@ export async function publishCandidate(options) {
             return await createStaleCandidateSkipResult(readyReadContext.localState.state);
         }
         try {
+            options.throwIfStopping?.();
             const published = await publishAttempt({
                 readContext: readyReadContext,
                 candidate: refreshedCandidate,
@@ -551,6 +599,7 @@ export async function publishCandidate(options) {
                 rpcFactory: options.rpcFactory,
                 runId: options.runId,
                 appendEventFn: options.appendEventFn,
+                throwIfStopping: options.throwIfStopping,
             });
             return {
                 ...published,
@@ -558,6 +607,29 @@ export async function publishCandidate(options) {
             };
         }
         catch (error) {
+            if (error instanceof ManagedCoreWalletRelockPendingError) {
+                const note = createManagedCoreWalletRelockRetryWaitingNote();
+                const lastError = error.message;
+                await options.appendEventFn(options.paths, createMiningEventRecord("publish-retry-pending", "Managed Bitcoin Core wallet relocked during mining publish and will be retried on the current tip.", {
+                    level: "warn",
+                    runId: options.runId,
+                    targetBlockHeight: refreshedCandidate.targetBlockHeight,
+                    referencedBlockHashDisplay: refreshedCandidate.referencedBlockHashDisplay,
+                    domainId: refreshedCandidate.domainId,
+                    domainName: refreshedCandidate.domainName,
+                    score: refreshedCandidate.canonicalBlend.toString(),
+                    reason: "managed-core-wallet-locked",
+                }));
+                return {
+                    state: readyReadContext.localState.state,
+                    txid: null,
+                    decision: "publish-retry-pending",
+                    note,
+                    lastError,
+                    retryable: true,
+                    candidate: refreshedCandidate,
+                };
+            }
             if (error instanceof Error && error.message === "wallet_mining_mempool_rejected_missing-inputs") {
                 const note = createRetryableMiningPublishWaitingNote();
                 const revertedState = error instanceof MiningPublishRejectedError

package/dist/wallet/mining/runner.d.ts

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { assaySentences } from "@cogcoin/scoring";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
@@ -13,7 +12,6 @@ import { type MiningRuntimeLoopState } from "./engine-state.js";
 import { saveStopSnapshot } from "./lifecycle.js";
 import type { CompetitivenessDecision, MiningCandidate, MiningCooperativeYield, MiningRpcClient } from "./engine-types.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
-import type { MiningRuntimeStatusV1 } from "./types.js";
 import { MiningFollowVisualizer } from "./visualizer.js";
 interface RunnerDependencies {
     openReadContext?: typeof openWalletReadContext;
@@ -23,8 +21,6 @@ interface RunnerDependencies {
     requestMiningPreemption?: typeof requestMiningGenerationPreemption;
     runMiningLoopImpl?: typeof runMiningLoop;
     saveStopSnapshotImpl?: typeof saveStopSnapshot;
-    spawnWorkerProcess?: typeof spawn;
-    waitForBackgroundHealthyImpl?: typeof waitForBackgroundHealthy;
     shutdownGraceMs?: number;
     sleepImpl?: typeof sleep;
 }
@@ -63,24 +59,6 @@ export interface RunForegroundMiningOptions extends RunnerDependencies {
     paths?: WalletRuntimePaths;
     visualizer?: MiningFollowVisualizer;
 }
-export interface StartBackgroundMiningOptions extends RunnerDependencies {
-    dataDir: string;
-    databasePath: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    builtInSetupEnsured?: boolean;
-    paths?: WalletRuntimePaths;
-}
-export interface StopBackgroundMiningOptions extends RunnerDependencies {
-    dataDir: string;
-    databasePath: string;
-    provider?: WalletSecretProvider;
-    paths?: WalletRuntimePaths;
-}
-export interface MiningStartResult {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
-}
 declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 declare function generateCandidatesForDomains(options: Parameters<typeof generateCandidatesForDomainsModule>[0]): Promise<MiningCandidate[]>;
 declare function runCompetitivenessGate(options: Parameters<typeof runCompetitivenessGateModule>[0]): Promise<CompetitivenessDecision>;
@@ -119,17 +97,7 @@ declare function runMiningLoop(options: {
     cooperativeYieldImpl?: MiningCooperativeYield;
     cooperativeYieldEvery?: number;
 }): Promise<void>;
-declare function waitForBackgroundHealthy(paths: WalletRuntimePaths): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
-export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
-export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;
-export declare function runBackgroundMiningWorker(options: RunnerDependencies & {
-    dataDir: string;
-    databasePath: string;
-    runId: string;
-    provider?: WalletSecretProvider;
-    paths?: WalletRuntimePaths;
-}): Promise<void>;
 export declare function performMiningCycleForTesting(options: {
     dataDir: string;
     databasePath: string;

package/dist/wallet/mining/runner.js

@@ -1,5 +1,4 @@
 import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
 import { getBalance, getBlockWinners, lookupDomain, lookupDomainById, } from "@cogcoin/indexer/queries";
 import { assaySentences, deriveBlendSeed, displayToInternalBlockhash, getWords, settleBlock, } from "@cogcoin/scoring";
 import { probeIndexerDaemon } from "../../bitcoind/indexer-daemon.js";
@@ -12,7 +11,8 @@ import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
 import { assertFixedInputPrefixMatches, buildWalletMutationTransaction, fundAndValidateWalletMutationDraft, isInsufficientFundsError, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { isMineableWalletDomain, openWalletReadContext, } from "../read/index.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
-import { createDefaultWalletSecretProvider, } from "../state/provider.js";
+import { createDefaultWalletSecretProvider, unlockClientPassword, withInteractiveWalletSecretProvider, } from "../state/provider.js";
+import { bindClientPasswordPromptSessionPolicy } from "../state/client-password/session-policy.js";
 import { serializeMine } from "../cogop/index.js";
 import { appendMiningEvent } from "./runtime-artifacts.js";
 import { loadClientConfig } from "./config.js";
@@ -29,7 +29,8 @@ import { attemptSaveMempool, handleDetectedMiningRuntimeResume, handleRecoverabl
 import { compareLexicographically, deriveMiningWordIndices, getBlockRewardCogtoshi, numberToSats, resolveBip39WordsFromIndices, rootDomain, tieBreakHash, } from "./engine-utils.js";
 import { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 import { clearMiningPublishState, miningPublishIsInMempool, miningPublishMayStillExist, normalizeMiningPublishState, normalizeMiningStateRecord, } from "./state.js";
-import { runBackgroundMiningWorker as runBackgroundMiningWorkerSupervisor, runForegroundMining as runForegroundMiningSupervisor, startBackgroundMining as startBackgroundMiningSupervisor, stopBackgroundMining as stopBackgroundMiningSupervisor, waitForBackgroundHealthy as waitForBackgroundHealthySupervisor, } from "./supervisor.js";
+import { runForegroundMining as runForegroundMiningSupervisor, } from "./supervisor.js";
+import { isMiningStopRequestedError, throwIfMiningStopRequested, } from "./stop.js";
 import { createMiningSentenceRequestLimits } from "./sentence-protocol.js";
 import { generateMiningSentences, MiningProviderRequestError } from "./sentences.js";
 import { MiningFollowVisualizer, } from "./visualizer.js";
@@ -106,6 +107,10 @@ function clearMiningGateCache(walletRootId) {
 }
 function sleep(ms, signal) {
     return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
         const timer = setTimeout(resolve, ms);
         signal?.addEventListener("abort", () => {
             clearTimeout(timer);
@@ -171,6 +176,9 @@ async function performMiningCycle(options) {
     const now = options.nowImpl ?? Date.now;
     const generateCandidatesForDomainsImpl = options.generateCandidatesForDomainsImpl ?? generateCandidatesForDomains;
     const runCompetitivenessGateImpl = options.runCompetitivenessGateImpl ?? runCompetitivenessGate;
+    const throwIfStopping = () => {
+        throwIfMiningStopRequested(options.signal);
+    };
     let readContext = await options.openReadContext({
         dataDir: options.dataDir,
         databasePath: options.databasePath,
@@ -179,6 +187,7 @@ async function performMiningCycle(options) {
     });
     let readContextClosed = false;
     try {
+        throwIfStopping();
         throwIfMiningSuspendDetected(options.suspendDetector);
         let clearRecoveredBitcoindError = false;
         const saveCycleStatus = async (readContext, overrides, includeVisualizer = true) => {
@@ -223,6 +232,7 @@ async function performMiningCycle(options) {
             startHeight: 0,
             walletRootId: readContext.localState.state.walletRootId,
         });
+        throwIfStopping();
         throwIfMiningSuspendDetected(options.suspendDetector);
         const rpc = options.rpcFactory(service.rpc);
         const reconciliation = await reconcileLiveMiningState({
@@ -232,6 +242,7 @@ async function performMiningCycle(options) {
             nodeBestHeight: readContext.nodeStatus?.nodeBestHeight ?? null,
             snapshotState: readContext.snapshot?.state ?? null,
         });
+        throwIfStopping();
         const reconciledState = reconciliation.state;
         throwIfMiningSuspendDetected(options.suspendDetector);
         let effectiveReadContext = readContext;
@@ -262,6 +273,7 @@ async function performMiningCycle(options) {
             indexedTipHeight: indexedTip?.height ?? null,
             indexedTipHashHex: indexedTip?.blockHashHex ?? null,
         }).catch(() => ({}));
+        throwIfStopping();
         syncMiningVisualizerBlockTimes(options.loopState, visibleBlockTimes);
         const { targetBlockHeight, tipKey, tipChanged } = syncMiningUiForCurrentTip({
             loopState: options.loopState,
@@ -351,6 +363,7 @@ async function performMiningCycle(options) {
             rpc.getNetworkInfo(),
             rpc.getMempoolInfo(),
         ]);
+        throwIfStopping();
         throwIfMiningSuspendDetected(options.suspendDetector);
         const corePublishState = determineCorePublishState({
             blockchain: blockchainInfo,
@@ -414,12 +427,17 @@ async function performMiningCycle(options) {
             nowImpl: now,
             saveCycleStatus: async (context, overrides) => await saveCycleStatus(context, overrides),
             appendEvent: async (event) => await appendEvent(options.paths, event),
+            stopSignal: options.signal,
+            throwIfStopping,
             throwIfSuspendDetected: () => {
                 throwIfMiningSuspendDetected(options.suspendDetector);
             },
         });
     }
     catch (error) {
+        if (isMiningStopRequestedError(error)) {
+            return;
+        }
         if (error instanceof MiningSuspendDetectedError) {
             discardMiningLoopTransientWork(options.loopState, readContext?.localState.walletRootId ?? undefined);
             if (readContext !== null && !readContextClosed) {
@@ -482,9 +500,13 @@ async function runMiningLoop(options) {
         }));
         while (!options.signal?.aborted) {
             try {
+                throwIfMiningStopRequested(options.signal);
                 throwIfMiningSuspendDetected(suspendDetector);
             }
             catch (error) {
+                if (isMiningStopRequestedError(error)) {
+                    break;
+                }
                 if (!(error instanceof MiningSuspendDetectedError)) {
                     throw error;
                 }
@@ -504,18 +526,35 @@ async function runMiningLoop(options) {
                 });
                 continue;
             }
-            await performMiningCycle({
-                ...options,
-                suspendDetector,
-                assaySentencesImpl: options.assaySentencesImpl,
-                cooperativeYieldImpl: options.cooperativeYieldImpl,
-                cooperativeYieldEvery: options.cooperativeYieldEvery,
-                loopState,
-                probeService,
-                stopService,
-            });
+            try {
+                await performMiningCycle({
+                    ...options,
+                    suspendDetector,
+                    assaySentencesImpl: options.assaySentencesImpl,
+                    cooperativeYieldImpl: options.cooperativeYieldImpl,
+                    cooperativeYieldEvery: options.cooperativeYieldEvery,
+                    loopState,
+                    probeService,
+                    stopService,
+                });
+            }
+            catch (error) {
+                if (isMiningStopRequestedError(error)) {
+                    break;
+                }
+                throw error;
+            }
+            if (options.signal?.aborted) {
+                break;
+            }
             await sleepImpl(Math.min(MINING_LOOP_INTERVAL_MS, MINING_STATUS_HEARTBEAT_INTERVAL_MS), options.signal);
         }
+        if (options.signal?.aborted) {
+            await appendEvent(options.paths, createEvent("runtime-stop", `Stopped ${options.runMode} mining runtime.`, {
+                runId: options.backgroundWorkerRunId,
+            }));
+            return;
+        }
         const service = await options.attachService({
             dataDir: options.dataDir,
             chain: "main",
@@ -537,29 +576,30 @@ async function runMiningLoop(options) {
         stopMiningSuspendDetector(suspendDetector);
     }
 }
-async function waitForBackgroundHealthy(paths) {
-    return await waitForBackgroundHealthySupervisor(paths);
-}
 export async function runForegroundMining(options) {
     if (!options.prompter.isInteractive) {
         throw new Error("mine_requires_tty");
     }
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
+    const miningPrompter = bindClientPasswordPromptSessionPolicy(options.prompter, "mining-indefinite");
+    const provider = withInteractiveWalletSecretProvider(options.provider ?? createDefaultWalletSecretProvider(), miningPrompter);
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
     const openReadContext = options.openReadContext ?? openWalletReadContext;
     const attachService = options.attachService ?? attachOrStartManagedBitcoindService;
-    const rpcFactory = options.rpcFactory ?? createRpcClient;
+    const rpcFactory = options.rpcFactory ?? ((config) => createRpcClient(config, {
+        abortSignal: options.signal,
+    }));
     const requestMiningPreemption = options.requestMiningPreemption ?? requestMiningGenerationPreemption;
     const setupReady = options.builtInSetupEnsured === true
         ? true
         : await ensureBuiltInMiningSetupIfNeeded({
             provider,
-            prompter: options.prompter,
+            prompter: miningPrompter,
             paths,
         });
     if (!setupReady) {
         throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
     }
+    await unlockClientPassword(provider, miningPrompter);
     await runForegroundMiningSupervisor({
         dataDir: options.dataDir,
         databasePath: options.databasePath,
@@ -587,91 +627,6 @@ export async function runForegroundMining(options) {
         },
     });
 }
-export async function startBackgroundMining(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const requestMiningPreemption = options.requestMiningPreemption ?? requestMiningGenerationPreemption;
-    const waitForBackgroundHealthyImpl = options.waitForBackgroundHealthyImpl ?? waitForBackgroundHealthy;
-    const openReadContext = options.openReadContext ?? openWalletReadContext;
-    const attachService = options.attachService ?? attachOrStartManagedBitcoindService;
-    const rpcFactory = options.rpcFactory ?? createRpcClient;
-    const setupReady = options.builtInSetupEnsured === true
-        ? true
-        : await ensureBuiltInMiningSetupIfNeeded({
-            provider,
-            prompter: options.prompter,
-            paths,
-        });
-    if (!setupReady) {
-        throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
-    }
-    return await startBackgroundMiningSupervisor({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        shutdownGraceMs: options.shutdownGraceMs,
-        waitForBackgroundHealthy: waitForBackgroundHealthyImpl,
-        runtime: {
-            provider,
-            paths,
-            openReadContext,
-            attachService,
-            rpcFactory,
-        },
-        deps: {
-            requestMiningPreemption,
-            spawnWorkerProcess: options.spawnWorkerProcess,
-            sleep: options.sleepImpl,
-        },
-    });
-}
-export async function stopBackgroundMining(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const openReadContext = options.openReadContext ?? openWalletReadContext;
-    const attachService = options.attachService ?? attachOrStartManagedBitcoindService;
-    const rpcFactory = options.rpcFactory ?? createRpcClient;
-    return await stopBackgroundMiningSupervisor({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        shutdownGraceMs: options.shutdownGraceMs,
-        runtime: {
-            provider,
-            paths,
-            openReadContext,
-            attachService,
-            rpcFactory,
-        },
-        deps: {
-            requestMiningPreemption: options.requestMiningPreemption,
-            saveStopSnapshot: options.saveStopSnapshotImpl,
-            sleep: options.sleepImpl,
-        },
-    });
-}
-export async function runBackgroundMiningWorker(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const openReadContext = options.openReadContext ?? openWalletReadContext;
-    const attachService = options.attachService ?? attachOrStartManagedBitcoindService;
-    const rpcFactory = options.rpcFactory ?? createRpcClient;
-    await runBackgroundMiningWorkerSupervisor({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        runId: options.runId,
-        fetchImpl: options.fetchImpl,
-        runtime: {
-            provider,
-            paths,
-            openReadContext,
-            attachService,
-            rpcFactory,
-        },
-        deps: {
-            runMiningLoop: options.runMiningLoopImpl ?? runMiningLoop,
-            saveStopSnapshot: options.saveStopSnapshotImpl,
-        },
-    });
-}
 export async function performMiningCycleForTesting(options) {
     await performMiningCycle({
         ...options,

package/dist/wallet/mining/stop.d.ts

@@ -0,0 +1,7 @@
+export declare const MINING_STOP_REQUESTED_ERROR_CODE = "mining_runtime_stop_requested";
+export declare class MiningStopRequestedError extends Error {
+    constructor();
+}
+export declare function isMiningStopRequestedError(error: unknown): error is Error;
+export declare function createMiningStopRequestedError(): MiningStopRequestedError;
+export declare function throwIfMiningStopRequested(signal: AbortSignal | undefined): void;

package/dist/wallet/mining/stop.js

@@ -0,0 +1,23 @@
+export const MINING_STOP_REQUESTED_ERROR_CODE = "mining_runtime_stop_requested";
+export class MiningStopRequestedError extends Error {
+    constructor() {
+        super(MINING_STOP_REQUESTED_ERROR_CODE);
+        this.name = "MiningStopRequestedError";
+    }
+}
+export function isMiningStopRequestedError(error) {
+    return error instanceof Error && error.message === MINING_STOP_REQUESTED_ERROR_CODE;
+}
+export function createMiningStopRequestedError() {
+    return new MiningStopRequestedError();
+}
+export function throwIfMiningStopRequested(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    throw createMiningStopRequestedError();
+}