@cogcoin/client 1.1.5 → 1.1.7

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();
+}

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

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
@@ -8,7 +7,6 @@ import { openWalletReadContext } from "../read/index.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import type { WalletSecretProvider } from "../state/provider.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
-import { inspectMiningControlPlane } from "./control.js";
 import { saveStopSnapshot } from "./lifecycle.js";
 import type { MiningRpcClient } from "./engine-types.js";
 import { loadMiningRuntimeStatus, saveMiningRuntimeStatus } from "./runtime-artifacts.js";
@@ -19,9 +17,8 @@ type AttachService = typeof attachOrStartManagedBitcoindService;
 type RpcFactory = (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
 type RequestMiningPreemption = typeof requestMiningGenerationPreemption;
 type SaveStopSnapshot = typeof saveStopSnapshot;
-type SpawnWorkerProcess = typeof spawn;
 type ProcessKill = typeof process.kill;
-type InspectMiningControlPlane = typeof inspectMiningControlPlane;
+type ForceExit = (code: number) => never | void;
 interface MiningLoopRunnerOptions {
     dataDir: string;
     databasePath: string;
@@ -51,9 +48,7 @@ export interface MiningSupervisorRuntimeContext {
 interface MiningSupervisorDependencies {
     requestMiningPreemption: RequestMiningPreemption;
     saveStopSnapshot: SaveStopSnapshot;
-    spawnWorkerProcess: SpawnWorkerProcess;
     runMiningLoop: RunMiningLoop;
-    inspectMiningControlPlane: InspectMiningControlPlane;
     loadRuntimeStatus: typeof loadMiningRuntimeStatus;
     saveRuntimeStatus: typeof saveMiningRuntimeStatus;
     acquireLock: typeof acquireFileLock;
@@ -64,12 +59,7 @@ interface MiningSupervisorDependencies {
     nowUnixMs: () => number;
     processKill: ProcessKill;
     processPid: number;
-    processExecPath: string;
-    resolveWorkerMainPath: () => string;
-}
-export interface MiningSupervisorStartResult {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
+    forceExit: ForceExit;
 }
 export interface MiningSupervisorTakeoverResult {
     controlLockCleared: boolean;
@@ -86,7 +76,6 @@ export declare function takeOverMiningRuntime(options: {
     shutdownGraceMs?: number;
     deps?: Partial<MiningSupervisorDependencies>;
 }): Promise<MiningSupervisorTakeoverResult>;
-export declare function waitForBackgroundHealthy(paths: WalletRuntimePaths, depsOverrides?: Partial<MiningSupervisorDependencies>): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: {
     dataDir: string;
     databasePath: string;
@@ -108,27 +97,4 @@ export declare function runForegroundMining(options: {
     runtime: MiningSupervisorRuntimeContext;
     deps?: Partial<MiningSupervisorDependencies>;
 }): Promise<void>;
-export declare function startBackgroundMining(options: {
-    dataDir: string;
-    databasePath: string;
-    shutdownGraceMs?: number;
-    waitForBackgroundHealthy?: (paths: WalletRuntimePaths) => Promise<MiningRuntimeStatusV1 | null>;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<MiningSupervisorStartResult>;
-export declare function stopBackgroundMining(options: {
-    dataDir: string;
-    databasePath: string;
-    shutdownGraceMs?: number;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<MiningRuntimeStatusV1 | null>;
-export declare function runBackgroundMiningWorker(options: {
-    dataDir: string;
-    databasePath: string;
-    runId: string;
-    fetchImpl?: typeof fetch;
-    runtime: MiningSupervisorRuntimeContext;
-    deps?: Partial<MiningSupervisorDependencies>;
-}): Promise<void>;
 export {};