@cogcoin/client 1.1.10 → 1.1.12

package/dist/wallet/mining/cycle.js

@@ -10,7 +10,7 @@ import { MiningProviderRequestError } from "./sentences.js";
 import { isInsufficientFundsError } from "../tx/common.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
-import { buildPrePublishStatusOverrides, } from "./projection.js";
+import { buildPrePublishStatusOverrides, resolveWaitingProviderNote, } from "./projection.js";
 function createInitialState(options) {
     return {
         phase: "idle",
@@ -149,7 +149,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState,
                             lastError: options.loopState.providerWaitLastError,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState),
                         });
                         return;
                     }
@@ -162,7 +162,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState,
                             lastError: options.loopState.providerWaitLastError,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState),
                         });
                         return;
                     }
@@ -231,7 +231,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState ?? error.providerState,
                             lastError: error.message,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState ?? error.providerState),
                         });
                         await options.appendEvent(createMiningEventRecord("publish-paused-provider", error.message, {
                             level: "warn",
@@ -339,6 +339,9 @@ export async function runMiningPhaseMachine(options) {
                     score: best.canonicalBlend.toString(),
                     runId: options.backgroundWorkerRunId,
                 }));
+                let lastScoringProgressProcessed = -1;
+                let lastScoringProgressSavedAtUnixMs = 0;
+                let scoringProgressWrite = Promise.resolve();
                 const gate = await runGateImpl({
                     rpc: options.rpc,
                     readContext: options.readContext,
@@ -348,7 +351,32 @@ export async function runMiningPhaseMachine(options) {
                     cooperativeYield: options.cooperativeYieldImpl,
                     cooperativeYieldEvery: options.cooperativeYieldEvery,
                     throwIfStopping: options.throwIfStopping,
+                    onWarmupProgress: async (progress) => {
+                        if (progress.total <= 0) {
+                            return;
+                        }
+                        const nowUnixMs = now();
+                        if (progress.processed === lastScoringProgressProcessed
+                            || (progress.processed !== 0
+                                && progress.processed !== progress.total
+                                && (nowUnixMs - lastScoringProgressSavedAtUnixMs) < 500)) {
+                            return;
+                        }
+                        lastScoringProgressProcessed = progress.processed;
+                        lastScoringProgressSavedAtUnixMs = nowUnixMs;
+                        scoringProgressWrite = scoringProgressWrite.then(async () => {
+                            await options.saveCycleStatus(options.readContext, {
+                                runMode: options.runMode,
+                                currentPhase: "scoring",
+                                currentPublishDecision: null,
+                                lastError: null,
+                                note: `Scoring mining candidates for the current tip (mempool ${progress.processed}/${progress.total}).`,
+                            });
+                        });
+                        await scoringProgressWrite;
+                    },
                 });
+                await scoringProgressWrite;
                 throwIfInterrupted();
                 state.gateSnapshot = {
                     higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,

package/dist/wallet/mining/engine-types.d.ts

@@ -28,6 +28,16 @@ export type MiningRpcClient = WalletMutationRpcClient & {
         txids: string[];
         mempool_sequence: string | number;
     }>;
+    getRawMempoolEntries(): Promise<Record<string, {
+        vsize: number;
+        fees: {
+            base: number;
+            ancestor: number;
+            descendant: number;
+        };
+        ancestorsize?: number;
+        descendantsize?: number;
+    }>>;
     getMempoolEntry(txid: string): Promise<{
         vsize: number;
         fees: {

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

@@ -37,6 +37,7 @@ export interface MiningRuntimeStatusOverrides {
     note?: string | null;
     livePublishInMempool?: boolean | null;
 }
+export declare function resolveWaitingProviderNote(providerState: MiningRuntimeStatusV1["providerState"] | null): string;
 export declare function buildPrePublishStatusOverrides(options: {
     state: WalletStateV1;
     candidate: MiningCandidate;

package/dist/wallet/mining/projection.js

@@ -1,6 +1,20 @@
 import { livePublishTargetsCandidateTip } from "./engine-state.js";
 import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
+export function resolveWaitingProviderNote(providerState) {
+    switch (providerState) {
+        case "backoff":
+            return "Mining is waiting because the sentence provider had a transient failure and will be retried automatically.";
+        case "rate-limited":
+            return "Mining is waiting because the sentence provider is rate limited and will be retried automatically.";
+        case "auth-error":
+            return "Mining is waiting because the sentence provider rejected the configured API key.";
+        case "not-found":
+            return "Mining is waiting because the configured sentence-provider model was not found.";
+        default:
+            return "Mining is waiting for the sentence provider to recover.";
+    }
+}
 export function buildPrePublishStatusOverrides(options) {
     const replacing = options.state.miningState.currentTxid !== null;
     const replacingAcrossTips = replacing && !livePublishTargetsCandidateTip({
@@ -249,7 +263,7 @@ export async function buildMiningRuntimeStatusSnapshot(options) {
             : 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."
+                    ? resolveWaitingProviderNote(existing?.providerState ?? providerState)
                     : existing?.currentPhase === "waiting-indexer"
                         ? "Mining is waiting for Bitcoin Core and the indexer to align."
                         : existing?.currentPhase === "waiting-bitcoin-network"

package/dist/wallet/mining/visualizer-sync.js

@@ -1,8 +1,9 @@
 import { getBalance, getBlockWinners, lookupDomainById, } from "@cogcoin/indexer/queries";
 import { displayToInternalBlockhash } from "@cogcoin/scoring";
 import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-times.js";
+import { readFundingBalanceSummary } from "../read/local-state.js";
 import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
-import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
+import { deriveMiningWordIndices, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
 function cloneSettledBoardEntries(entries) {
     return entries.map((entry) => ({
@@ -156,14 +157,11 @@ export function syncMiningUiForCurrentTip(options) {
     };
 }
 export async function resolveFundingDisplaySats(state, rpc) {
-    const utxos = await rpc.listUnspent(state.managedCoreWallet.walletName, 0);
-    return utxos.reduce((sum, entry) => {
-        if (entry.scriptPubKey !== state.funding.scriptPubKeyHex
-            || entry.spendable === false) {
-            return sum;
-        }
-        return sum + numberToSats(entry.amount);
-    }, 0n);
+    const summary = await readFundingBalanceSummary({
+        state,
+        rpc,
+    });
+    return summary.fundingDisplaySats ?? 0n;
 }
 export async function loadMiningVisibleFollowBlockTimes(options) {
     if (options.indexedTipHeight === null || options.indexedTipHashHex === null) {

package/dist/wallet/mining/visualizer.js

@@ -3,6 +3,7 @@ import { centerLine, normalizeInlineText, truncateLine } from "../../bitcoind/pr
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "../../bitcoind/progress/render-policy.js";
 import { TtyProgressRenderer } from "../../bitcoind/progress/tty-renderer.js";
+import { resolveWaitingProviderNote } from "./projection.js";
 const MINING_ARTWORK_COG_WIDTH = 22;
 const MINING_SENTENCE_BOARD_SIZE = 5;
 const MINING_SENTENCE_BOARD_WRAP_WIDTH = 80;
@@ -282,7 +283,7 @@ export function describeMiningVisualizerProgress(snapshot) {
         case "resuming":
             return "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health.";
         case "waiting-provider":
-            return "Mining is waiting for the sentence provider to recover.";
+            return resolveWaitingProviderNote(snapshot.providerState);
         case "waiting-indexer":
             return "Mining is waiting for Bitcoin Core and the indexer to align.";
         case "waiting-bitcoin-network":

package/dist/wallet/read/context.js

@@ -5,7 +5,7 @@ import { inspectMiningControlPlane } from "../mining/index.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { openManagedWalletReadServiceBundle } from "./managed-services.js";
-import { inspectWalletLocalState, readFundingSpendableSats } from "./local-state.js";
+import { inspectWalletLocalState, readFundingBalanceSummary } from "./local-state.js";
 import { createWalletReadModel } from "./project.js";
 const DEFAULT_SERVICE_START_TIMEOUT_MS = 60_000;
 export async function openWalletReadContext(options) {
@@ -31,7 +31,7 @@ export async function openWalletReadContext(options) {
         expectedIndexerBinaryVersion,
         now,
     });
-    const fundingSpendableSats = await readFundingSpendableSats({
+    const { fundingDisplaySats, fundingSpendableSats, } = await readFundingBalanceSummary({
         state: localState.state,
         rpc: managedServices.node.rpc,
     });
@@ -58,6 +58,7 @@ export async function openWalletReadContext(options) {
         model: localState.state === null
             ? null
             : createWalletReadModel(localState.state, managedServices.snapshot),
+        fundingDisplaySats,
         fundingSpendableSats,
         mining,
         async close() {

package/dist/wallet/read/local-state.d.ts

@@ -7,6 +7,10 @@ type WalletLocalStateDeps = {
     attachOrStartManagedBitcoindService: typeof attachOrStartManagedBitcoindService;
     createRpcClient: typeof createRpcClient;
 };
+export interface FundingBalanceSummary {
+    fundingDisplaySats: bigint | null;
+    fundingSpendableSats: bigint | null;
+}
 export declare function inspectWalletLocalStateWithDependencies(options?: {
     dataDir?: string;
     secretProvider?: WalletSecretProvider;
@@ -25,4 +29,8 @@ export declare function readFundingSpendableSats(options: {
     state: WalletLocalStateStatus["state"];
     rpc: ReturnType<typeof createRpcClient> | null;
 }): Promise<bigint | null>;
+export declare function readFundingBalanceSummary(options: {
+    state: WalletLocalStateStatus["state"];
+    rpc: Pick<ReturnType<typeof createRpcClient>, "listUnspent"> | null;
+}): Promise<FundingBalanceSummary>;
 export {};

package/dist/wallet/read/local-state.js

@@ -22,6 +22,10 @@ function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
         && entry.spendable !== false
         && entry.safe !== false;
 }
+function isDisplayFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.spendable !== false;
+}
 async function pathExists(path) {
     try {
         await access(path, constants.F_OK);
@@ -217,17 +221,39 @@ export async function inspectWalletLocalState(options = {}) {
     return inspectWalletLocalStateWithDependencies(options);
 }
 export async function readFundingSpendableSats(options) {
+    return (await readFundingBalanceSummary(options)).fundingSpendableSats;
+}
+export async function readFundingBalanceSummary(options) {
     if (options.state === null || options.rpc === null) {
-        return null;
+        return {
+            fundingDisplaySats: null,
+            fundingSpendableSats: null,
+        };
     }
     const state = options.state;
     try {
-        const utxos = await options.rpc.listUnspent(state.managedCoreWallet.walletName, 1);
-        return utxos.reduce((sum, entry) => isSpendableFundingUtxo(entry, state.funding.scriptPubKeyHex)
-            ? sum + btcAmountToSats(entry.amount)
-            : sum, 0n);
+        const utxos = await options.rpc.listUnspent(state.managedCoreWallet.walletName, 0);
+        let fundingDisplaySats = 0n;
+        let fundingSpendableSats = 0n;
+        for (const entry of utxos) {
+            if (!isDisplayFundingUtxo(entry, state.funding.scriptPubKeyHex)) {
+                continue;
+            }
+            const amountSats = btcAmountToSats(entry.amount);
+            fundingDisplaySats += amountSats;
+            if (isSpendableFundingUtxo(entry, state.funding.scriptPubKeyHex)) {
+                fundingSpendableSats += amountSats;
+            }
+        }
+        return {
+            fundingDisplaySats,
+            fundingSpendableSats,
+        };
     }
     catch {
-        return null;
+        return {
+            fundingDisplaySats: null,
+            fundingSpendableSats: null,
+        };
     }
 }

package/dist/wallet/read/types.d.ts

@@ -94,6 +94,7 @@ export interface WalletReadContext {
     indexer: WalletIndexerStatus;
     snapshot: WalletSnapshotView | null;
     model: WalletReadModel | null;
+    fundingDisplaySats: bigint | null;
     fundingSpendableSats: bigint | null;
     mining?: MiningControlPlaneView;
     close(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",