@cogcoin/client 1.1.4 → 1.1.5

package/dist/wallet/mining/control.js

@@ -5,20 +5,11 @@ import { loadWalletState } from "../state/storage.js";
 import { isRootDomainName } from "../read/filter.js";
 import { appendMiningEvent, getLastMiningEventTimestamp, loadMiningRuntimeStatus, readMiningEvents, saveMiningRuntimeStatus, followMiningEvents, } from "./runtime-artifacts.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
-import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { loadClientConfig, saveBuiltInMiningProviderConfig } from "./config.js";
-import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
+import { buildMiningRuntimeStatusSnapshot } from "./projection.js";
 import { estimateBuiltInModelDailyCost, getBuiltInProviderModelCatalog, getRecommendedBuiltInProviderModel, MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION, resolveBuiltInProviderSelection, } from "./provider-model.js";
+import { createMiningEventRecord } from "./events.js";
 const KEEP_CURRENT_MODEL_SELECTION = "__keep_current__";
-function createMiningEvent(kind, message, options = {}) {
-    return {
-        schemaVersion: 1,
-        timestampUnixMs: options.timestampUnixMs ?? Date.now(),
-        level: options.level ?? "info",
-        kind,
-        message,
-    };
-}
 function buildProviderInspection(options) {
     if (options.error !== null) {
         return {
@@ -86,241 +77,6 @@ function countEligibleAnchoredRoots(localState) {
     }
     return count;
 }
-async function isProcessAlive(pid) {
-    if (pid === null) {
-        return false;
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
-            return false;
-        }
-        return true;
-    }
-}
-function mapProviderState(provider, localState, existingRuntime) {
-    const miningState = localState.state?.miningState === undefined
-        ? null
-        : normalizeMiningStateRecord(localState.state.miningState);
-    if (existingRuntime?.currentPhase === "waiting-provider"
-        && existingRuntime.providerState !== null
-        && (miningState === null || miningState.state === "idle")) {
-        return existingRuntime.providerState;
-    }
-    if (miningState?.state === "paused" && miningState.pauseReason?.includes("rate-limit")) {
-        return "rate-limited";
-    }
-    if (miningState?.state === "paused" && miningState.pauseReason?.includes("auth")) {
-        return "auth-error";
-    }
-    if (miningState?.state === "paused" && miningState.pauseReason?.includes("provider")) {
-        return "backoff";
-    }
-    if (provider.status === "ready") {
-        return "ready";
-    }
-    return "unavailable";
-}
-function shouldReuseExistingProviderWait(options) {
-    return options.existingRuntime?.currentPhase === "waiting-provider"
-        && options.existingRuntime.providerState !== null
-        && (options.miningState === null || options.miningState.state === "idle");
-}
-function mapIndexerDaemonState(indexer) {
-    if (indexer.health === "wallet-root-mismatch") {
-        return "wallet-root-mismatch";
-    }
-    if (indexer.health === "service-version-mismatch") {
-        return "service-version-mismatch";
-    }
-    if (indexer.health === "schema-mismatch") {
-        return "schema-mismatch";
-    }
-    if (indexer.status !== null) {
-        switch (indexer.status.state) {
-            case "synced":
-                return indexer.health === "stale-heartbeat" ? "stale-heartbeat" : "synced";
-            case "catching-up":
-                return indexer.health === "stale-heartbeat" ? "stale-heartbeat" : "catching-up";
-            case "reorging":
-                return indexer.health === "stale-heartbeat" ? "stale-heartbeat" : "reorging";
-            case "starting":
-            case "stopping":
-                return indexer.health === "stale-heartbeat" ? "stale-heartbeat" : "starting";
-            case "failed":
-                return "failed";
-            case "schema-mismatch":
-                return "schema-mismatch";
-            case "service-version-mismatch":
-                return "service-version-mismatch";
-            default:
-                break;
-        }
-    }
-    switch (indexer.health) {
-        case "failed":
-            return "failed";
-        case "starting":
-            return "starting";
-        case "catching-up":
-            return "catching-up";
-        case "reorging":
-            return "reorging";
-        case "stale-heartbeat":
-            return "stale-heartbeat";
-        case "synced":
-            return "synced";
-        default:
-            return "unavailable";
-    }
-}
-function mapCorePublishState(nodeHealth, nodeStatus) {
-    if (nodeStatus === null || !nodeStatus.ready) {
-        return "unknown";
-    }
-    if (nodeHealth === "catching-up") {
-        return "ibd";
-    }
-    return "healthy";
-}
-async function deriveBackgroundWorkerHealth(options) {
-    const runtime = options.runtime;
-    if (runtime?.runMode !== "background") {
-        return null;
-    }
-    if (runtime.walletRootId !== null
-        && options.localState.walletRootId !== null
-        && runtime.walletRootId !== options.localState.walletRootId) {
-        return "version-mismatch";
-    }
-    if (runtime.workerApiVersion !== null && runtime.workerApiVersion !== MINING_WORKER_API_VERSION) {
-        return "version-mismatch";
-    }
-    if (!await isProcessAlive(runtime.backgroundWorkerPid)) {
-        return "stale-pid";
-    }
-    if (runtime.backgroundWorkerHeartbeatAtUnixMs === null
-        || (options.nowUnixMs - runtime.backgroundWorkerHeartbeatAtUnixMs) > MINING_WORKER_HEARTBEAT_STALE_MS) {
-        return "stale-heartbeat";
-    }
-    return "healthy";
-}
-async function buildMiningRuntimeSnapshot(options) {
-    const state = options.localState.state?.miningState === undefined
-        ? null
-        : normalizeMiningStateRecord(options.localState.state.miningState);
-    const backgroundWorkerHealth = await deriveBackgroundWorkerHealth({
-        runtime: options.existingRuntime,
-        localState: options.localState,
-        nowUnixMs: options.nowUnixMs,
-    });
-    const providerState = mapProviderState(options.provider, options.localState, options.existingRuntime);
-    const indexerDaemonState = mapIndexerDaemonState(options.indexer);
-    const corePublishState = mapCorePublishState(options.nodeHealth, options.nodeStatus);
-    const existing = options.existingRuntime;
-    const reuseExistingProviderWait = shouldReuseExistingProviderWait({
-        existingRuntime: existing,
-        miningState: state,
-    });
-    return {
-        schemaVersion: 1,
-        walletRootId: options.localState.walletRootId,
-        workerApiVersion: existing?.workerApiVersion ?? null,
-        workerBinaryVersion: existing?.workerBinaryVersion ?? null,
-        workerBuildId: existing?.workerBuildId ?? null,
-        updatedAtUnixMs: options.nowUnixMs,
-        runMode: state?.runMode ?? existing?.runMode ?? "stopped",
-        backgroundWorkerPid: existing?.backgroundWorkerPid ?? null,
-        backgroundWorkerRunId: existing?.backgroundWorkerRunId ?? null,
-        backgroundWorkerHeartbeatAtUnixMs: existing?.backgroundWorkerHeartbeatAtUnixMs ?? null,
-        backgroundWorkerHealth,
-        indexerDaemonState,
-        indexerDaemonInstanceId: options.indexer.daemonInstanceId ?? null,
-        indexerSnapshotSeq: options.indexer.snapshotSeq ?? null,
-        indexerSnapshotOpenedAtUnixMs: options.indexer.openedAtUnixMs ?? null,
-        indexerTruthSource: options.indexer.source ?? "none",
-        indexerHeartbeatAtUnixMs: options.indexer.status?.heartbeatAtUnixMs ?? null,
-        coreBestHeight: options.nodeStatus?.nodeBestHeight ?? options.indexer.status?.coreBestHeight ?? existing?.coreBestHeight ?? null,
-        coreBestHash: options.nodeStatus?.nodeBestHashHex ?? options.indexer.status?.coreBestHash ?? existing?.coreBestHash ?? null,
-        indexerTipHeight: options.indexer.snapshotTip?.height ?? options.indexer.status?.appliedTipHeight ?? null,
-        indexerTipHash: options.indexer.snapshotTip?.blockHashHex ?? options.indexer.status?.appliedTipHash ?? null,
-        indexerReorgDepth: options.indexer.status?.reorgDepth ?? null,
-        indexerTipAligned: options.tipsAligned,
-        corePublishState,
-        providerState,
-        lastSuspendDetectedAtUnixMs: existing?.lastSuspendDetectedAtUnixMs ?? null,
-        reconnectSettledUntilUnixMs: existing?.reconnectSettledUntilUnixMs ?? null,
-        tipSettledUntilUnixMs: existing?.tipSettledUntilUnixMs ?? null,
-        miningState: state?.state ?? existing?.miningState ?? "idle",
-        currentPhase: existing?.currentPhase ?? "idle",
-        currentPublishState: normalizeMiningPublishState(state?.currentPublishState ?? options.existingRuntime?.currentPublishState ?? "none"),
-        targetBlockHeight: state?.currentBlockTargetHeight ?? existing?.targetBlockHeight ?? null,
-        referencedBlockHashDisplay: state?.currentReferencedBlockHashDisplay ?? existing?.referencedBlockHashDisplay ?? null,
-        currentDomainId: state?.currentDomainId ?? existing?.currentDomainId ?? null,
-        currentDomainName: state?.currentDomain ?? existing?.currentDomainName ?? null,
-        currentSentenceDisplay: state?.currentSentence ?? existing?.currentSentenceDisplay ?? null,
-        currentCanonicalBlend: state?.currentScore ?? existing?.currentCanonicalBlend ?? null,
-        currentTxid: state?.currentTxid ?? existing?.currentTxid ?? null,
-        currentWtxid: state?.currentWtxid ?? existing?.currentWtxid ?? null,
-        livePublishInMempool: state?.livePublishInMempool ?? existing?.livePublishInMempool ?? null,
-        currentFeeRateSatVb: state?.currentFeeRateSatVb ?? existing?.currentFeeRateSatVb ?? null,
-        currentAbsoluteFeeSats: state?.currentAbsoluteFeeSats ?? existing?.currentAbsoluteFeeSats ?? null,
-        currentBlockFeeSpentSats: state?.currentBlockFeeSpentSats ?? existing?.currentBlockFeeSpentSats ?? "0",
-        sessionFeeSpentSats: state?.sessionFeeSpentSats ?? existing?.sessionFeeSpentSats ?? "0",
-        lifetimeFeeSpentSats: state?.lifetimeFeeSpentSats ?? existing?.lifetimeFeeSpentSats ?? "0",
-        sameDomainCompetitorSuppressed: existing?.sameDomainCompetitorSuppressed ?? null,
-        higherRankedCompetitorDomainCount: existing?.higherRankedCompetitorDomainCount ?? null,
-        dedupedCompetitorDomainCount: existing?.dedupedCompetitorDomainCount ?? null,
-        competitivenessGateIndeterminate: existing?.competitivenessGateIndeterminate ?? null,
-        mempoolSequenceCacheStatus: existing?.mempoolSequenceCacheStatus ?? null,
-        currentPublishDecision: state?.currentPublishDecision ?? existing?.currentPublishDecision ?? null,
-        lastMempoolSequence: existing?.lastMempoolSequence ?? null,
-        lastCompetitivenessGateAtUnixMs: existing?.lastCompetitivenessGateAtUnixMs ?? null,
-        pauseReason: state?.pauseReason ?? options.existingRuntime?.pauseReason ?? null,
-        providerConfigured: options.provider.configured,
-        providerKind: options.provider.provider,
-        bitcoindHealth: options.bitcoind.health,
-        bitcoindServiceState: options.nodeStatus?.serviceStatus?.state ?? null,
-        bitcoindReplicaStatus: options.nodeStatus?.walletReplica?.proofStatus ?? null,
-        nodeHealth: options.nodeHealth,
-        indexerHealth: options.indexer.health,
-        tipsAligned: options.tipsAligned,
-        lastEventAtUnixMs: options.lastEventAtUnixMs,
-        lastError: reuseExistingProviderWait
-            ? existing?.lastError ?? null
-            : existing?.currentPhase === "waiting-bitcoin-network" || existing?.currentPhase === "waiting-indexer"
-                ? existing?.lastError ?? options.provider.message ?? options.indexer.message ?? null
-                : options.provider.message ?? options.indexer.message ?? null,
-        note: state?.pauseReason === "zero-reward"
-            ? "Mining is disabled because the target block reward is zero."
-            : existing?.currentPhase === "resuming"
-                ? "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health."
-                : reuseExistingProviderWait
-                    ? "Mining is waiting for the sentence provider to recover."
-                    : existing?.currentPhase === "waiting-indexer"
-                        ? "Mining is waiting for Bitcoin Core and the indexer to align."
-                        : existing?.currentPhase === "waiting-bitcoin-network"
-                            ? "Mining is waiting for the local Bitcoin node to become publishable."
-                            : state?.state === "repair-required"
-                                ? "Mining is blocked until the current mining publish is reconciled or `cogcoin repair` completes."
-                                : state?.state === "paused-stale" && state.livePublishInMempool
-                                    ? "A previously broadcast mining transaction is still in mempool for an older tip context. Wait for confirmation or rerun mining to replace it."
-                                    : state?.state === "paused" && state.livePublishInMempool
-                                        ? "Mining is paused, but the last mining transaction may still confirm from mempool without further fee bumps."
-                                        : state?.state === "paused"
-                                            ? "Mining is paused by another wallet command or local policy."
-                                            : options.provider.status === "missing"
-                                                ? "Run `cogcoin mine setup` to configure the built-in mining provider."
-                                                : options.indexer.health === "reorging"
-                                                    ? "Mining remains stopped while the indexer replays a reorg and refreshes the coherent snapshot."
-                                                    : options.indexer.health !== "synced" || options.nodeHealth !== "synced"
-                                                        ? "Mining remains stopped until Bitcoin Core and the indexer are both healthy and aligned."
-                                                        : null,
-    };
-}
 async function loadMiningProviderConfig(options) {
     try {
         const config = await loadClientConfig({
@@ -356,7 +112,7 @@ export async function inspectMiningControlPlane(options) {
     const nodeBestHeight = options.nodeStatus?.nodeBestHeight ?? null;
     const indexerHeight = options.indexer.snapshotTip?.height ?? null;
     const tipsAligned = nodeBestHeight === null || indexerHeight === null ? null : nodeBestHeight === indexerHeight;
-    const runtime = await buildMiningRuntimeSnapshot({
+    const runtime = await buildMiningRuntimeStatusSnapshot({
         nowUnixMs,
         localState: options.localState,
         bitcoind: options.bitcoind,
@@ -633,7 +389,7 @@ export async function setupBuiltInMining(options) {
                 path: paths.clientConfigPath,
                 provider,
             }).catch(() => null);
-            await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
+            await appendMiningEvent(paths.miningEventsPath, createMiningEventRecord("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
             try {
                 const config = await promptForMiningProviderConfig(options.prompter, eligibleRootCount, {
                     currentConfig: clientConfig?.mining.builtIn ?? null,
@@ -646,7 +402,7 @@ export async function setupBuiltInMining(options) {
                     secretReference: createWalletSecretReference(loaded.state.walletRootId),
                     config,
                 });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider with model ${config.modelOverride} (${describeModelSelectionSource(config.modelSelectionSource)}).`, { timestampUnixMs: nowUnixMs }));
+                await appendMiningEvent(paths.miningEventsPath, createMiningEventRecord("mine-setup-completed", `Configured the built-in ${config.provider} mining provider with model ${config.modelOverride} (${describeModelSelectionSource(config.modelSelectionSource)}).`, { timestampUnixMs: nowUnixMs }));
                 return refreshMiningRuntimeStatus({
                     provider,
                     localState,
@@ -673,13 +429,13 @@ export async function setupBuiltInMining(options) {
             }
             catch (error) {
                 if (error instanceof Error && error.message === "mining_setup_canceled") {
-                    await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-canceled", "Canceled built-in mining provider setup.", {
+                    await appendMiningEvent(paths.miningEventsPath, createMiningEventRecord("mine-setup-canceled", "Canceled built-in mining provider setup.", {
                         level: "warn",
                         timestampUnixMs: nowUnixMs,
                     }));
                     throw error;
                 }
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-failed", error instanceof Error ? error.message : String(error), {
+                await appendMiningEvent(paths.miningEventsPath, createMiningEventRecord("mine-setup-failed", error instanceof Error ? error.message : String(error), {
                     level: "error",
                     timestampUnixMs: nowUnixMs,
                 }));

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

@@ -0,0 +1,39 @@
+import { assaySentences } from "@cogcoin/scoring";
+import { openWalletReadContext, type WalletReadContext } from "../read/index.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { WalletSecretProvider } from "../state/provider.js";
+import type { MiningCooperativeYield, MiningRpcClient, ReadyMiningReadContext } from "./engine-types.js";
+import type { MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
+import { generateCandidatesForDomains } from "./candidate.js";
+import { runCompetitivenessGate } from "./competitiveness.js";
+import { type MiningRuntimeLoopState } from "./engine-state.js";
+import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import { createRpcClient } from "../../bitcoind/node.js";
+import { type MiningRuntimeStatusOverrides } from "./projection.js";
+export declare function runMiningPhaseMachine(options: {
+    dataDir: string;
+    databasePath: string;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    runMode: "foreground" | "background";
+    backgroundWorkerRunId: string | null;
+    readContext: ReadyMiningReadContext;
+    rpc: MiningRpcClient;
+    targetBlockHeight: number | null;
+    tipKey: string | null;
+    corePublishState: MiningRuntimeStatusV1["corePublishState"];
+    loopState: MiningRuntimeLoopState;
+    openReadContext: typeof openWalletReadContext;
+    attachService: typeof attachOrStartManagedBitcoindService;
+    rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
+    fetchImpl?: typeof fetch;
+    generateCandidatesForDomainsImpl?: typeof generateCandidatesForDomains;
+    runCompetitivenessGateImpl?: typeof runCompetitivenessGate;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYieldImpl?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
+    nowImpl?: () => number;
+    saveCycleStatus: (readContext: WalletReadContext, overrides: MiningRuntimeStatusOverrides) => Promise<MiningRuntimeStatusV1>;
+    appendEvent: (event: MiningEventRecord) => Promise<void>;
+    throwIfSuspendDetected?: () => void;
+}): Promise<void>;