@cogcoin/client 1.1.0 → 1.1.2

package/dist/bitcoind/client/sync-engine.js

@@ -317,6 +317,6 @@ export async function syncToTip(dependencies) {
             lastError: message,
             message: "Managed sync can be resumed after the last error.",
         });
-        throw new Error(message);
+        throw new Error(message, { cause: error instanceof Error ? error : undefined });
     }
 }

package/dist/bitcoind/indexer-daemon-main.js

@@ -5,6 +5,7 @@ import { loadBundledGenesisParameters, serializeIndexerState } from "@cogcoin/in
 import { openManagedBitcoindClientInternal } from "./client.js";
 import { DEFAULT_SNAPSHOT_METADATA } from "./bootstrap.js";
 import { openClient } from "../client.js";
+import { readPackageVersionFromDisk } from "../package-version.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
 import { createRpcClient } from "./node.js";
@@ -55,16 +56,6 @@ async function withTimeout(promise, timeoutMs, errorCode) {
         }
     }
 }
-async function readPackageVersionFromDisk() {
-    try {
-        const raw = await readFile(new URL("../../package.json", import.meta.url), "utf8");
-        const parsed = JSON.parse(raw);
-        return parsed.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}
 function createSnapshotKey(appliedTip) {
     return appliedTip === null
         ? "__null__"
@@ -177,7 +168,7 @@ async function main() {
     const walletRootId = parseArg("wallet-root-id") || UNINITIALIZED_WALLET_ROOT_ID;
     const paths = resolveManagedServicePaths(dataDir, walletRootId);
     const daemonInstanceId = randomUUID();
-    const binaryVersion = await readPackageVersionFromDisk();
+    const binaryVersion = await readPackageVersionFromDisk().catch(() => "0.0.0");
     const genesisParameters = await loadBundledGenesisParameters();
     const startedAtUnixMs = Date.now();
     const snapshots = new Map();

package/dist/bitcoind/indexer-daemon.js

@@ -3,12 +3,14 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import net from "node:net";
-import { compareSemver } from "../semver.js";
+import { compareSemver, parseSemver } from "../semver.js";
 import { acquireFileLock, FileLockBusyError } from "../wallet/fs/lock.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
 import { INDEXER_DAEMON_SCHEMA_VERSION, INDEXER_DAEMON_SERVICE_API_VERSION, } from "./types.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
 const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
+const FORCE_KILL_TIMEOUT_MS = 5_000;
 const INDEXER_DAEMON_REQUEST_TIMEOUT_MS = 15_000;
 const INDEXER_DAEMON_RESUME_BACKGROUND_FOLLOW_REQUEST_TIMEOUT_MS = 35_000;
 const INDEXER_DAEMON_BACKGROUND_FOLLOW_NOT_ACTIVE = "indexer_daemon_background_follow_not_active";
@@ -58,6 +60,11 @@ async function clearIndexerDaemonRuntimeArtifacts(paths) {
     await rm(paths.indexerDaemonStatusPath, { force: true }).catch(() => undefined);
     await rm(paths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
 }
+function ignoreProcessNotFound(error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+        throw error;
+    }
+}
 export async function stopIndexerDaemonServiceWithLockHeld(options) {
     const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
     const paths = options.paths ?? resolveManagedServicePaths(options.dataDir, walletRootId);
@@ -74,11 +81,23 @@ export async function stopIndexerDaemonServiceWithLockHeld(options) {
         process.kill(processId, "SIGTERM");
     }
     catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+        ignoreProcessNotFound(error);
+    }
+    try {
+        await waitForProcessExit(processId, options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, "indexer_daemon_stop_timeout");
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.message !== "indexer_daemon_stop_timeout") {
             throw error;
         }
+        try {
+            process.kill(processId, "SIGKILL");
+        }
+        catch (killError) {
+            ignoreProcessNotFound(killError);
+        }
+        await waitForProcessExit(processId, FORCE_KILL_TIMEOUT_MS, "indexer_daemon_stop_timeout");
     }
-    await waitForProcessExit(processId, options.shutdownTimeoutMs ?? 5_000, "indexer_daemon_stop_timeout");
     await clearIndexerDaemonRuntimeArtifacts(paths);
     return {
         status: "stopped",
@@ -283,8 +302,11 @@ function isStaleIndexerDaemonVersion(status, expectedBinaryVersion) {
     if (status === null || expectedBinaryVersion === null || expectedBinaryVersion === undefined) {
         return false;
     }
+    if (parseSemver(expectedBinaryVersion) === null) {
+        return false;
+    }
     const comparison = compareSemver(status.binaryVersion, expectedBinaryVersion);
-    return comparison !== null && comparison < 0;
+    return comparison === null || comparison < 0;
 }
 async function probeIndexerDaemonAtSocket(socketPath, expectedWalletRootId) {
     const client = createIndexerDaemonClient(socketPath);

package/dist/bitcoind/indexer-monitor.js

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { readPackageVersionFromDisk } from "../package-version.js";
 import { attachOrStartIndexerDaemon, readObservedIndexerDaemonStatus, } from "./indexer-daemon.js";
 import { resolveCogcoinProcessingStartHeight } from "./processing-start-height.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
@@ -31,6 +32,9 @@ async function resolveStartOptions(options) {
     };
 }
 export async function openManagedIndexerMonitor(options) {
+    const expectedBinaryVersion = options.expectedBinaryVersion === undefined
+        ? await readPackageVersionFromDisk()
+        : options.expectedBinaryVersion;
     const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
     const startOptions = await resolveStartOptions({
         dataDir: options.dataDir,
@@ -49,7 +53,7 @@ export async function openManagedIndexerMonitor(options) {
         walletRootId,
         startupTimeoutMs: options.startupTimeoutMs,
         ensureBackgroundFollow: true,
-        expectedBinaryVersion: options.expectedBinaryVersion,
+        expectedBinaryVersion,
     });
     return createManagedIndexerMonitor({
         daemon,

package/dist/bitcoind/progress/controller.js

@@ -128,8 +128,11 @@ export class ManagedProgressController {
             this.#cogcoinSyncTargetHeight = null;
         }
         if (this.#followVisualMode) {
+            const followIndexedHeight = phase === "follow_tip"
+                ? this.#cogcoinSyncHeight ?? this.#progress.blocks ?? this.#followScene.indexedHeight
+                : undefined;
             syncFollowSceneState(this.#followScene, {
-                indexedHeight: phase === "follow_tip" ? this.#cogcoinSyncHeight : undefined,
+                indexedHeight: followIndexedHeight,
                 nodeHeight: this.#progress.blocks,
                 liveActivated: phase === "follow_tip" || this.#followScene.liveActivated,
             });

package/dist/bitcoind/progress/follow-scene.js

@@ -110,7 +110,13 @@ function renderFollowStatusField(statusFieldText, options) {
     return field;
 }
 function highestTrackedFollowHeight(state) {
-    return Math.max(state.indexedHeight ?? Number.NEGATIVE_INFINITY, state.displayedCenterHeight ?? Number.NEGATIVE_INFINITY, state.animation?.height ?? Number.NEGATIVE_INFINITY, ...state.queuedHeights);
+    let highest = Math.max(state.indexedHeight ?? Number.NEGATIVE_INFINITY, state.displayedCenterHeight ?? Number.NEGATIVE_INFINITY, state.animation?.height ?? Number.NEGATIVE_INFINITY);
+    for (const height of state.queuedHeights) {
+        if (height > highest) {
+            highest = height;
+        }
+    }
+    return highest;
 }
 function resolveLatestAuthoritativeFollowHeight(indexedHeight, nodeHeight) {
     if (indexedHeight === null) {

package/dist/cli/context.d.ts

@@ -1,3 +1,2 @@
 import type { CliRunnerContext, RequiredCliRunnerContext } from "./types.js";
-export declare function readPackageVersionFromDisk(): Promise<string>;
 export declare function createDefaultContext(overrides?: CliRunnerContext): RequiredCliRunnerContext;

package/dist/cli/context.js

@@ -1,11 +1,12 @@
 import { spawn } from "node:child_process";
-import { mkdir, readFile } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService, } from "../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService, } from "../bitcoind/service.js";
 import { resolveDefaultBitcoindDataDirForTesting, resolveDefaultClientDatabasePathForTesting, resolveDefaultUpdateCheckStatePathForTesting, } from "../app-paths.js";
 import { openManagedBitcoindClient } from "../bitcoind/index.js";
 import { openManagedIndexerMonitor } from "../bitcoind/indexer-monitor.js";
+import { readPackageVersionFromDisk } from "../package-version.js";
 import { inspectPassiveClientStatus } from "../passive-status.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import { initializeWallet, deleteImportedWalletSeed, previewResetWallet, repairWallet, resetWallet, restoreWalletFromMnemonic, showWalletMnemonic, } from "../wallet/lifecycle.js";
@@ -16,28 +17,6 @@ import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControl
 import { createLazyDefaultWalletSecretProvider } from "../wallet/state/provider.js";
 import { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain, } from "../wallet/tx/index.js";
 import { createTerminalPrompter } from "./prompt.js";
-export async function readPackageVersionFromDisk() {
-    const packageUrls = [
-        new URL("../../package.json", import.meta.url),
-        new URL("../../../package.json", import.meta.url),
-    ];
-    for (const packageUrl of packageUrls) {
-        try {
-            const raw = await readFile(packageUrl, "utf8");
-            const parsed = JSON.parse(raw);
-            return parsed.version ?? "0.0.0";
-        }
-        catch (error) {
-            const code = typeof error === "object" && error !== null && "code" in error
-                ? String(error.code)
-                : null;
-            if (code !== "ENOENT") {
-                throw error;
-            }
-        }
-    }
-    return "0.0.0";
-}
 async function runGlobalClientUpdateInstall(options) {
     const binary = process.platform === "win32" ? "npm.cmd" : "npm";
     await new Promise((resolve, reject) => {

package/dist/package-version.d.ts

@@ -0,0 +1 @@
+export declare function readPackageVersionFromDisk(): Promise<string>;

package/dist/package-version.js

@@ -0,0 +1,17 @@
+import { readFile } from "node:fs/promises";
+export async function readPackageVersionFromDisk() {
+    try {
+        const raw = await readFile(new URL("../package.json", import.meta.url), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version ?? "0.0.0";
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code)
+            : null;
+        if (code === "ENOENT") {
+            return "0.0.0";
+        }
+        throw error;
+    }
+}

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;