@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/mining/index.js

@@ -1,6 +1,5 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
-export { disableMiningHooks, enableMiningHooks, followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
+export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
 export { runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
-export { ensureMiningHookTemplate, inspectMiningHookState, runGenerateSentencesHookRequest, validateCustomMiningHook, } from "./hooks.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

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

@@ -1,13 +1,14 @@
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import type { ProgressOutputMode } from "../../bitcoind/types.js";
-import { type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
-import { type WalletPrompter } from "../lifecycle.js";
-import { openWalletReadContext } from "../read/index.js";
+import { type FixedWalletInput, type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
+import type { WalletPrompter } from "../lifecycle.js";
+import { openWalletReadContext, type WalletReadContext } from "../read/index.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { MiningStateRecord } from "../types.js";
-import type { MiningRuntimeStatusV1 } from "./types.js";
+import type { MiningStateRecord, OutpointRecord, WalletStateV1 } from "../types.js";
+import type { MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
+import { type MiningFollowVisualizerState, type MiningSentenceBoardEntry } from "./visualizer.js";
 type MiningRpcClient = WalletMutationRpcClient & {
     getBlockchainInfo(): Promise<{
         blocks: number;
@@ -18,6 +19,13 @@ type MiningRpcClient = WalletMutationRpcClient & {
         networkactive: boolean;
         connections_out?: number;
     }>;
+    getBlockHash(height: number): Promise<string>;
+    getBlock(hashHex: string): Promise<{
+        hash: string;
+        previousblockhash?: string;
+        height: number;
+        time?: number;
+    }>;
     getMempoolInfo(): Promise<{
         loaded: boolean;
     }>;
@@ -64,12 +72,66 @@ type MiningRpcClient = WalletMutationRpcClient & {
     sendRawTransaction(hex: string): Promise<string>;
     saveMempool?(): Promise<null>;
 };
+interface MiningCandidate {
+    domainId: number;
+    domainName: string;
+    localIndex: number;
+    sender: MutationSender;
+    sentence: string;
+    encodedSentenceBytes: Uint8Array;
+    bip39WordIndices: number[];
+    bip39Words: readonly string[];
+    canonicalBlend: bigint;
+    referencedBlockHashDisplay: string;
+    referencedBlockHashInternal: Uint8Array;
+    targetBlockHeight: number;
+}
+type ReadyMiningReadContext = WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+};
+interface MiningPublishSkipResult {
+    state: WalletStateV1;
+    txid: null;
+    decision: "publish-skipped-stale-candidate";
+    note: string;
+    skipped: true;
+    retryable?: false;
+    candidate: null;
+}
+interface MiningPublishRetryResult {
+    state: WalletStateV1;
+    txid: null;
+    decision: "publish-retry-pending";
+    note: string;
+    skipped?: false;
+    retryable: true;
+    candidate: MiningCandidate;
+}
+type MiningPublishOutcome = ({
+    skipped?: false;
+    retryable?: false;
+    note?: null;
+    candidate: MiningCandidate;
+} & Awaited<ReturnType<typeof publishCandidateOnce>>) | MiningPublishSkipResult | MiningPublishRetryResult;
 interface RunnerDependencies {
     openReadContext?: typeof openWalletReadContext;
     attachService?: typeof attachOrStartManagedBitcoindService;
     rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     fetchImpl?: typeof fetch;
 }
+interface MiningLoopState {
+    attemptedTipKey: string | null;
+    currentTipKey: string | null;
+    selectedCandidateTipKey: string | null;
+    selectedCandidate: MiningCandidate | null;
+    ui: MiningFollowVisualizerState;
+    waitingNote: string | null;
+}
 export interface RunForegroundMiningOptions extends RunnerDependencies {
     dataDir: string;
     databasePath: string;
@@ -104,6 +166,116 @@ export interface MiningStartResult {
     started: boolean;
     snapshot: MiningRuntimeStatusV1 | null;
 }
+export declare function createMiningLoopStateForTesting(): MiningLoopState;
+export declare function resetMiningUiForTipForTesting(loopState: MiningLoopState, targetBlockHeight: number | null): void;
+export declare function resolveSettledBoardForTesting(options: {
+    snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined;
+    snapshotTipHeight: number | null;
+    nodeBestHeight: number | null;
+}): {
+    settledBlockHeight: number | null;
+    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 resolveFundingDisplaySatsForTesting(state: WalletStateV1, rpc: MiningRpcClient): Promise<bigint>;
+export declare function loadMiningVisibleFollowBlockTimesForTesting(options: {
+    rpc: MiningRpcClient;
+    indexedTipHeight: number | null;
+    indexedTipHashHex: string | null;
+}): Promise<Record<number, number>>;
+export declare function syncMiningVisualizerBlockTimesForTesting(loopState: MiningLoopState, blockTimesByHeight: Record<number, number>): void;
+declare function appendEvent(paths: WalletRuntimePaths, event: MiningEventRecord): Promise<void>;
+declare function createMiningPlan(options: {
+    state: WalletStateV1;
+    candidate: MiningCandidate;
+    conflictOutpoint: OutpointRecord | null;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord | null;
+    feeRateSatVb: number;
+};
+export declare function createMiningPlanForTesting(options: {
+    state: WalletStateV1;
+    candidate: {
+        domainId: number;
+        domainName: string;
+        localIndex: number;
+        sender: MutationSender;
+        sentence: string;
+        encodedSentenceBytes: Uint8Array;
+        bip39WordIndices: number[];
+        bip39Words: readonly string[];
+        canonicalBlend: bigint;
+        referencedBlockHashDisplay: string;
+        referencedBlockHashInternal: Uint8Array;
+        targetBlockHeight: number;
+    };
+    conflictOutpoint: OutpointRecord;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord | null;
+    feeRateSatVb: number;
+};
+export declare function validateMiningDraftForTesting(decoded: Awaited<ReturnType<MiningRpcClient["decodePsbt"]>>, funded: Awaited<ReturnType<MiningRpcClient["walletCreateFundedPsbt"]>>, plan: ReturnType<typeof createMiningPlan>): void;
+export declare function refreshMiningCandidateFromCurrentStateForTesting(context: ReadyMiningReadContext, candidate: MiningCandidate): MiningCandidate | null;
+export declare function resolveMiningConflictOutpointForTesting(options: {
+    state: WalletStateV1;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+}): OutpointRecord | null;
+declare function publishCandidateOnce(options: {
+    readContext: WalletReadContext & {
+        localState: {
+            availability: "ready";
+            state: WalletStateV1;
+        };
+        snapshot: NonNullable<WalletReadContext["snapshot"]>;
+        model: NonNullable<WalletReadContext["model"]>;
+    };
+    candidate: MiningCandidate;
+    dataDir: string;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    attachService: typeof attachOrStartManagedBitcoindService;
+    rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
+    runId: string | null;
+}): Promise<{
+    state: WalletStateV1;
+    txid: string | null;
+    decision: string;
+}>;
+export declare function publishCandidateForTesting(options: {
+    candidate: MiningCandidate;
+    dataDir: string;
+    databasePath: string;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    fallbackState: WalletStateV1;
+    openReadContext: typeof openWalletReadContext;
+    attachService: typeof attachOrStartManagedBitcoindService;
+    rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
+    runId: string | null;
+    publishAttempt?: typeof publishCandidateOnce;
+    appendEventFn?: typeof appendEvent;
+}): Promise<MiningPublishOutcome>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
 export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
 export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;
@@ -141,8 +313,9 @@ export declare function performMiningCycleForTesting(options: {
     stdout?: {
         write(chunk: string): void;
     };
+    loopState?: MiningLoopState;
 }): Promise<void>;
-export declare function shouldTreatCandidateAsFeeBumpForTesting(options: {
+export declare function shouldKeepCurrentTipLivePublishForTesting(options: {
     liveState: MiningStateRecord;
     candidate: {
         domainId: number;