@cogcoin/client 1.1.1 → 1.1.3

package/dist/wallet/mining/control.js

@@ -105,7 +105,9 @@ function mapProviderState(provider, localState, existingRuntime) {
     const miningState = localState.state?.miningState === undefined
         ? null
         : normalizeMiningStateRecord(localState.state.miningState);
-    if (existingRuntime?.currentPhase === "waiting-provider" && existingRuntime.providerState !== null) {
+    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")) {
@@ -122,6 +124,11 @@ function mapProviderState(provider, localState, existingRuntime) {
     }
     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";
@@ -214,6 +221,10 @@ async function buildMiningRuntimeSnapshot(options) {
     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,
@@ -278,12 +289,16 @@ async function buildMiningRuntimeSnapshot(options) {
         indexerHealth: options.indexer.health,
         tipsAligned: options.tipsAligned,
         lastEventAtUnixMs: options.lastEventAtUnixMs,
-        lastError: existing?.lastError ?? options.provider.message ?? options.indexer.message ?? null,
+        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."
-                : existing?.currentPhase === "waiting-provider"
+                : 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."

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

@@ -1,4 +1,5 @@
 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";
 import type { ProgressOutputMode } from "../../bitcoind/types.js";
@@ -158,6 +159,18 @@ type MiningPublishOutcome = ({
     note?: null;
     candidate: MiningCandidate;
 } & Awaited<ReturnType<typeof publishCandidateOnce>>) | MiningPublishSkipResult | MiningPublishRetryResult;
+interface CompetitivenessDecision {
+    allowed: boolean;
+    decision: string;
+    sameDomainCompetitorSuppressed: boolean;
+    higherRankedCompetitorDomainCount: number;
+    dedupedCompetitorDomainCount: number;
+    competitivenessGateIndeterminate: boolean;
+    mempoolSequenceCacheStatus: MiningRuntimeStatusV1["mempoolSequenceCacheStatus"];
+    lastMempoolSequence: string | null;
+    visibleBoardEntries: MiningSentenceBoardEntry[];
+    candidateRank: number | null;
+}
 interface RunnerDependencies {
     openReadContext?: typeof openWalletReadContext;
     attachService?: typeof attachOrStartManagedBitcoindService;
@@ -171,6 +184,11 @@ interface RunnerDependencies {
     shutdownGraceMs?: number;
     sleepImpl?: typeof sleep;
 }
+interface IndexerTruthKey {
+    walletRootId: string;
+    daemonInstanceId: string;
+    snapshotSeq: string;
+}
 interface MiningLoopState {
     attemptedTipKey: string | null;
     currentTipKey: string | null;
@@ -178,6 +196,10 @@ interface MiningLoopState {
     selectedCandidate: MiningCandidate | null;
     ui: MiningFollowVisualizerState;
     waitingNote: string | null;
+    providerWaitState: "backoff" | "rate-limited" | "auth-error" | "not-found" | null;
+    providerWaitLastError: string | null;
+    providerWaitNextRetryAtUnixMs: number | null;
+    providerTransientFailureCount: number;
     bitcoinRecoveryFirstFailureAtUnixMs: number | null;
     bitcoinRecoveryFirstUnreachableAtUnixMs: number | null;
     bitcoinRecoveryLastRestartAttemptAtUnixMs: number | null;
@@ -186,6 +208,20 @@ interface MiningLoopState {
     reconnectSettledUntilUnixMs: number | null;
     tipSettledUntilUnixMs: number | null;
 }
+interface MiningSuspendDetector {
+    lastHeartbeatMonotonicMs: number;
+    detectedAtUnixMs: number | null;
+    monotonicNow: () => number;
+    nowUnixMs: () => number;
+    stop(): void;
+}
+interface MiningSuspendHeartbeatHandle {
+    clear(): void;
+}
+interface MiningSuspendScheduler {
+    every(intervalMs: number, callback: () => void): MiningSuspendHeartbeatHandle;
+}
+type MiningCooperativeYield = () => Promise<void>;
 export interface RunForegroundMiningOptions extends RunnerDependencies {
     dataDir: string;
     databasePath: string;
@@ -243,7 +279,7 @@ export declare function resolveSettledBoardForTesting(options: {
     settledBoardEntries: MiningSentenceBoardEntry[];
 };
 export declare function getSelectedCandidateForTipForTesting(loopState: MiningLoopState, tipKey: string | null): MiningCandidate | null;
-export declare function cacheSelectedCandidateForTipForTesting(loopState: MiningLoopState, tipKey: string | null, candidate: MiningCandidate): void;
+export declare function cacheSelectedCandidateForTipForTesting(loopState: MiningLoopState, tipKey: string | null, candidate: MiningCandidate, liveState?: MiningStateRecord | null): void;
 export declare function resolveFundingDisplaySatsForTesting(state: WalletStateV1, rpc: MiningRpcClient): Promise<bigint>;
 export declare function loadMiningVisibleFollowBlockTimesForTesting(options: {
     rpc: MiningRpcClient;
@@ -302,6 +338,12 @@ export declare function createMiningPlanForTesting(options: {
     feeRateSatVb: number;
 };
 export declare function validateMiningDraftForTesting(decoded: Awaited<ReturnType<MiningRpcClient["decodePsbt"]>>, funded: Awaited<ReturnType<MiningRpcClient["walletCreateFundedPsbt"]>>, plan: ReturnType<typeof createMiningPlan>): void;
+declare function resolveEligibleAnchoredRoots(context: WalletReadContext): Array<{
+    domainId: number;
+    domainName: string;
+    localIndex: number;
+    sender: MutationSender;
+}>;
 export declare function refreshMiningCandidateFromCurrentStateForTesting(context: ReadyMiningReadContext, candidate: MiningCandidate): MiningCandidate | null;
 export declare function resolveMiningConflictOutpointForTesting(options: {
     state: WalletStateV1;
@@ -320,6 +362,34 @@ export declare function buildMiningGenerationRequestForTesting(options: {
     domainExtraPrompts?: Record<string, string>;
     extraPrompt?: string | null;
 }): MiningSentenceGenerationRequest;
+declare function generateCandidatesForDomains(options: {
+    rpc: MiningRpcClient;
+    readContext: WalletReadContext & {
+        localState: {
+            availability: "ready";
+            state: WalletStateV1;
+        };
+        snapshot: NonNullable<WalletReadContext["snapshot"]>;
+        model: NonNullable<WalletReadContext["model"]>;
+    };
+    domains: ReturnType<typeof resolveEligibleAnchoredRoots>;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    indexerTruthKey: IndexerTruthKey | null;
+    runId?: string | null;
+    fetchImpl?: typeof fetch;
+}): Promise<MiningCandidate[]>;
+declare function runCompetitivenessGate(options: {
+    rpc: MiningRpcClient;
+    readContext: WalletReadContext & {
+        snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    };
+    candidate: MiningCandidate;
+    currentTxid: string | null;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYield?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
+}): Promise<CompetitivenessDecision>;
 declare function publishCandidateOnce(options: {
     readContext: WalletReadContext & {
         localState: {
@@ -388,9 +458,17 @@ declare function runMiningLoop(options: {
     stdout?: {
         write(chunk: string): void;
     };
+    loopState?: MiningLoopState;
     visualizer?: MiningFollowVisualizer;
     nowImpl?: () => number;
     sleepImpl?: typeof sleep;
+    suspendMonotonicNowImpl?: () => number;
+    suspendScheduler?: MiningSuspendScheduler;
+    generateCandidatesForDomainsImpl?: typeof generateCandidatesForDomains;
+    runCompetitivenessGateImpl?: typeof runCompetitivenessGate;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYieldImpl?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
 }): Promise<void>;
 declare function waitForBackgroundHealthy(paths: WalletRuntimePaths): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
@@ -445,6 +523,11 @@ export declare function performMiningCycleForTesting(options: {
     };
     loopState?: MiningLoopState;
     nowImpl?: () => number;
+    generateCandidatesForDomainsImpl?: typeof generateCandidatesForDomains;
+    runCompetitivenessGateImpl?: typeof runCompetitivenessGate;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYieldImpl?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
 }): Promise<void>;
 export declare function runMiningLoopForTesting(options: {
     dataDir: string;
@@ -464,10 +547,42 @@ export declare function runMiningLoopForTesting(options: {
     stdout?: {
         write(chunk: string): void;
     };
+    loopState?: MiningLoopState;
     visualizer?: MiningFollowVisualizer;
     nowImpl?: () => number;
     sleepImpl?: typeof sleep;
+    suspendMonotonicNowImpl?: () => number;
+    suspendScheduler?: MiningSuspendScheduler;
+    generateCandidatesForDomainsImpl?: typeof generateCandidatesForDomains;
+    runCompetitivenessGateImpl?: typeof runCompetitivenessGate;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYieldImpl?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
 }): Promise<void>;
+export declare function runCompetitivenessGateForTesting(options: {
+    rpc: MiningRpcClient;
+    readContext: WalletReadContext & {
+        snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    };
+    candidate: MiningCandidate;
+    currentTxid: string | null;
+    assaySentencesImpl?: typeof assaySentences;
+    cooperativeYieldImpl?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
+}): Promise<CompetitivenessDecision>;
+export declare function createMiningSuspendDetectorForTesting(options?: {
+    monotonicNow?: () => number;
+    nowUnixMs?: () => number;
+    scheduler?: MiningSuspendScheduler;
+}): MiningSuspendDetector;
+export declare function throwIfMiningSuspendDetectedForTesting(detector: MiningSuspendDetector): void;
+export declare function topologicallyOrderAncestorTxidsForTesting(options: {
+    txid: string;
+    txContexts: Map<string, {
+        txid: string;
+        rawTransaction: Awaited<ReturnType<MiningRpcClient["getRawTransaction"]>>;
+    }>;
+}): string[] | null;
 export declare function buildPrePublishStatusOverridesForTesting(options: {
     state: WalletStateV1;
     candidate: MiningCandidate;