@cogcoin/client 1.1.7 → 1.1.8

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@1.1.7` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@1.1.8` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 

package/dist/bitcoind/service.js

@@ -20,7 +20,7 @@ import { DEFAULT_MANAGED_BITCOIND_FOLLOW_POLL_INTERVAL_MS, MANAGED_BITCOIND_SERV
 const execFileAsync = promisify(execFile);
 const LOCAL_HOST = "127.0.0.1";
 const SUPPORTED_BITCOIND_VERSION = "30.2.0";
-const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
+const DEFAULT_STARTUP_TIMEOUT_MS = 60_000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 15_000;
 const DEFAULT_DBCACHE_MIB = 450;
 const claimedUninitializedRuntimeKeys = new Set();

package/dist/wallet/mining/engine-state.js

@@ -135,13 +135,23 @@ export function buildMiningTipKey(bestBlockHash, targetBlockHeight) {
     }
     return `${bestBlockHash}:${targetBlockHeight}`;
 }
+function cloneSettledBoardEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        requiredWords: [...entry.requiredWords],
+    }));
+}
 export function resetMiningUiForTip(loopState, _targetBlockHeight) {
     const preservedTxid = loopState.ui.latestTxid;
     const preservedFundingAddress = loopState.ui.fundingAddress;
+    const preservedSettledBlockHeight = loopState.ui.settledBlockHeight;
+    const preservedSettledBoardEntries = cloneSettledBoardEntries(loopState.ui.settledBoardEntries);
     loopState.ui = {
         ...createEmptyMiningFollowVisualizerState(),
         fundingAddress: preservedFundingAddress,
         latestTxid: preservedTxid,
+        settledBlockHeight: preservedSettledBlockHeight,
+        settledBoardEntries: preservedSettledBoardEntries,
     };
     loopState.selectedCandidateTipKey = null;
     loopState.selectedCandidate = null;

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

@@ -4,6 +4,12 @@ import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-
 import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
 import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
+function cloneSettledBoardEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        requiredWords: [...entry.requiredWords],
+    }));
+}
 function resolveSettledWinnerRequiredWords(options) {
     const storedWords = resolveBip39WordsFromIndices(options.bip39WordIndices);
     if (storedWords.length > 0) {
@@ -20,6 +26,46 @@ function resolveSettledWinnerRequiredWords(options) {
 function fallbackSettledWinnerDomainName(domainId) {
     return `domain-${domainId}`;
 }
+function resolveSettledBoardEntriesForHeight(options) {
+    if (options.snapshotState === null || options.snapshotState === undefined) {
+        return null;
+    }
+    const winners = getBlockWinners(options.snapshotState, options.blockHeight);
+    if (winners === null) {
+        return null;
+    }
+    const snapshotState = options.snapshotState;
+    return winners
+        .slice()
+        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
+        .slice(0, 5)
+        .map((winner) => ({
+        rank: winner.rank,
+        domainName: lookupDomainById(snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
+        sentence: winner.sentenceText ?? "[unavailable]",
+        requiredWords: resolveSettledWinnerRequiredWords({
+            domainId: winner.domainId,
+            bip39WordIndices: winner.bip39WordIndices,
+            snapshotTipPreviousHashHex: options.blockPreviousHashHex,
+        }),
+    }));
+}
+function resolveLatestPriorNonEmptySettledBoard(options) {
+    for (let blockHeight = options.snapshotTipHeight - 1; blockHeight >= 0; blockHeight -= 1) {
+        const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+            snapshotState: options.snapshotState,
+            blockHeight,
+            blockPreviousHashHex: null,
+        });
+        if (settledBoardEntries !== null && settledBoardEntries.length > 0) {
+            return {
+                settledBlockHeight: blockHeight,
+                settledBoardEntries,
+            };
+        }
+    }
+    return null;
+}
 function resolveCurrentMinedBlockBoard(options) {
     const settledBlockHeight = options.snapshotTipHeight ?? null;
     if (settledBlockHeight === null) {
@@ -34,23 +80,37 @@ function resolveCurrentMinedBlockBoard(options) {
             settledBoardEntries: [],
         };
     }
-    const settledBoardEntries = (getBlockWinners(options.snapshotState, settledBlockHeight) ?? [])
-        .slice()
-        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
-        .slice(0, 5)
-        .map((winner) => ({
-        rank: winner.rank,
-        domainName: lookupDomainById(options.snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
-        sentence: winner.sentenceText ?? "[unavailable]",
-        requiredWords: resolveSettledWinnerRequiredWords({
-            domainId: winner.domainId,
-            bip39WordIndices: winner.bip39WordIndices,
-            snapshotTipPreviousHashHex: options.snapshotTipPreviousHashHex,
-        }),
-    }));
+    const settledBoardEntries = resolveSettledBoardEntriesForHeight({
+        snapshotState: options.snapshotState,
+        blockHeight: settledBlockHeight,
+        blockPreviousHashHex: options.snapshotTipPreviousHashHex,
+    });
+    if (settledBoardEntries !== null) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries,
+        };
+    }
+    const currentDisplayedBlockHeight = options.currentDisplayedBoard?.settledBlockHeight ?? null;
+    const currentDisplayedEntries = options.currentDisplayedBoard?.settledBoardEntries ?? [];
+    if (currentDisplayedBlockHeight !== null
+        && currentDisplayedBlockHeight <= settledBlockHeight
+        && currentDisplayedEntries.length > 0) {
+        return {
+            settledBlockHeight: currentDisplayedBlockHeight,
+            settledBoardEntries: cloneSettledBoardEntries(currentDisplayedEntries),
+        };
+    }
+    const latestPriorNonEmptyBoard = resolveLatestPriorNonEmptySettledBoard({
+        snapshotState: options.snapshotState,
+        snapshotTipHeight: settledBlockHeight,
+    });
+    if (latestPriorNonEmptyBoard !== null) {
+        return latestPriorNonEmptyBoard;
+    }
     return {
         settledBlockHeight,
-        settledBoardEntries,
+        settledBoardEntries: [],
     };
 }
 export function resolveSettledBoard(options) {
@@ -66,6 +126,10 @@ function syncMiningUiSettledBoard(loopState, snapshotState, snapshotTipHeight, s
         snapshotState,
         snapshotTipHeight,
         snapshotTipPreviousHashHex,
+        currentDisplayedBoard: {
+            settledBlockHeight: loopState.ui.settledBlockHeight,
+            settledBoardEntries: loopState.ui.settledBoardEntries,
+        },
     });
     loopState.ui.settledBlockHeight = settledBoard.settledBlockHeight;
     loopState.ui.settledBoardEntries = settledBoard.settledBoardEntries;

package/dist/wallet/read/context.js

@@ -16,7 +16,7 @@ import { createDefaultWalletSecretProvider, createWalletSecretReference, inspect
 import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.js";
 import { openManagedWalletReadServiceBundle } from "./managed-services.js";
 import { createWalletReadModel } from "./project.js";
-const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
+const DEFAULT_SERVICE_START_TIMEOUT_MS = 60_000;
 function btcAmountToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }

package/dist/wallet/reset/artifacts.d.ts

@@ -0,0 +1,16 @@
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { StagedArtifact, WalletResetArtifactDependencies } from "./types.js";
+export declare function pathExists(path: string, deps?: WalletResetArtifactDependencies): Promise<boolean>;
+export declare function readJsonFileOrNull<T>(path: string, deps?: WalletResetArtifactDependencies): Promise<T | null>;
+export declare function isPathWithin(root: string, target: string): boolean;
+export declare function dedupeSortedPaths(candidates: readonly string[]): string[];
+export declare function resolveDefaultRemovedRoots(paths: WalletRuntimePaths): string[];
+export declare function resolveBitcoindPreservingRemovedRoots(paths: WalletRuntimePaths): string[];
+export declare function resolveRemovedRoots(paths: WalletRuntimePaths, options?: {
+    preserveBitcoinDataDir: boolean;
+}): string[];
+export declare function isDeletedByRemovalPlan(removedRoots: readonly string[], targetPath: string): boolean;
+export declare function stageArtifact(sourcePath: string, stagingRoot: string, label: string, deps?: WalletResetArtifactDependencies): Promise<StagedArtifact | null>;
+export declare function restoreStagedArtifacts(artifacts: readonly StagedArtifact[], deps?: WalletResetArtifactDependencies): Promise<void>;
+export declare function deleteRemovedRoots(roots: readonly string[], deps?: WalletResetArtifactDependencies): Promise<void>;
+export declare function deleteBootstrapSnapshotArtifacts(dataDir: string, deps?: WalletResetArtifactDependencies): Promise<void>;

package/dist/wallet/reset/artifacts.js

@@ -0,0 +1,141 @@
+import { access, constants, copyFile, mkdir, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { DEFAULT_SNAPSHOT_METADATA } from "../../bitcoind/bootstrap/constants.js";
+import { resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap/paths.js";
+import { resolveLegacyHooksRootPath } from "../../app-paths.js";
+function resolveArtifactDependencies(overrides = {}) {
+    return {
+        access: overrides.access ?? access,
+        copyFile: overrides.copyFile ?? copyFile,
+        mkdir: overrides.mkdir ?? mkdir,
+        readFile: overrides.readFile ?? readFile,
+        rename: overrides.rename ?? rename,
+        remove: overrides.remove ?? rm,
+    };
+}
+export async function pathExists(path, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        await resolved.access(path, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function readJsonFileOrNull(path, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        return JSON.parse(await resolved.readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+export function isPathWithin(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && rel !== ".");
+}
+export function dedupeSortedPaths(candidates) {
+    return [...new Set(candidates)].sort((left, right) => right.length - left.length);
+}
+export function resolveDefaultRemovedRoots(paths) {
+    const configRoot = dirname(paths.clientConfigPath);
+    return dedupeSortedPaths([
+        paths.dataRoot,
+        paths.stateRoot,
+        paths.runtimeRoot,
+        configRoot,
+    ]);
+}
+export function resolveBitcoindPreservingRemovedRoots(paths) {
+    const configRoot = dirname(paths.clientConfigPath);
+    return dedupeSortedPaths([
+        paths.clientDataDir,
+        paths.indexerRoot,
+        paths.stateRoot,
+        paths.runtimeRoot,
+        configRoot,
+        resolveLegacyHooksRootPath({
+            dataRoot: paths.dataRoot,
+            clientConfigPath: paths.clientConfigPath,
+        }),
+    ]);
+}
+export function resolveRemovedRoots(paths, options = {
+    preserveBitcoinDataDir: false,
+}) {
+    return options.preserveBitcoinDataDir
+        ? resolveBitcoindPreservingRemovedRoots(paths)
+        : resolveDefaultRemovedRoots(paths);
+}
+export function isDeletedByRemovalPlan(removedRoots, targetPath) {
+    return removedRoots.some((root) => isPathWithin(root, targetPath));
+}
+async function moveFile(sourcePath, destinationPath, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    await resolved.mkdir(dirname(destinationPath), { recursive: true });
+    try {
+        await resolved.rename(sourcePath, destinationPath);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "EXDEV") {
+            throw error;
+        }
+        await resolved.copyFile(sourcePath, destinationPath);
+        await resolved.remove(sourcePath, { force: true });
+    }
+}
+export async function stageArtifact(sourcePath, stagingRoot, label, deps = {}) {
+    if (!await pathExists(sourcePath, deps)) {
+        return null;
+    }
+    const stagedPath = join(stagingRoot, label);
+    await moveFile(sourcePath, stagedPath, deps);
+    return {
+        originalPath: sourcePath,
+        stagedPath,
+        restorePath: sourcePath,
+    };
+}
+export async function restoreStagedArtifacts(artifacts, deps = {}) {
+    for (const artifact of artifacts) {
+        if (!await pathExists(artifact.stagedPath, deps)) {
+            continue;
+        }
+        await moveFile(artifact.stagedPath, artifact.restorePath, deps);
+    }
+}
+export async function deleteRemovedRoots(roots, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    try {
+        for (const root of roots) {
+            await resolved.remove(root, {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+    catch {
+        throw new Error("reset_data_root_delete_failed");
+    }
+}
+export async function deleteBootstrapSnapshotArtifacts(dataDir, deps = {}) {
+    const resolved = resolveArtifactDependencies(deps);
+    const snapshotPaths = resolveBootstrapPathsForTesting(dataDir, DEFAULT_SNAPSHOT_METADATA);
+    await Promise.all([
+        snapshotPaths.snapshotPath,
+        snapshotPaths.partialSnapshotPath,
+        snapshotPaths.statePath,
+        snapshotPaths.quoteStatePath,
+    ].map(async (path) => resolved.remove(path, {
+        recursive: false,
+        force: true,
+    })));
+}

package/dist/wallet/reset/execution.d.ts

@@ -0,0 +1,38 @@
+import { type WalletRuntimePaths } from "../runtime.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import { type WalletStateSaveAccess } from "../state/storage.js";
+import type { WalletStateV1 } from "../types.js";
+import { preflightReset } from "./preflight.js";
+import type { ResetExecutionDecision, WalletAccessForReset, WalletResetAction, WalletResetBitcoinDataDirResultStatus, WalletResetExecutionOptions, WalletResetPreflight, WalletResetResult, WalletResetSnapshotResultStatus } from "./types.js";
+export declare function loadWalletForEntropyReset(options: {
+    wallet: WalletResetPreflight["wallet"];
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+}): Promise<WalletAccessForReset>;
+export declare function createEntropyRetainedWalletState(previousState: WalletStateV1, nowUnixMs: number): WalletStateV1;
+export declare function recreateManagedCoreWalletReplicaForReset(options: {
+    state: WalletStateV1;
+    access: WalletStateSaveAccess;
+    paths: NonNullable<WalletResetExecutionOptions["paths"]>;
+    dataDir: string;
+    nowUnixMs: number;
+    attachService?: WalletResetExecutionOptions["attachService"];
+    rpcFactory?: WalletResetExecutionOptions["rpcFactory"];
+}): Promise<WalletStateV1>;
+export declare function resolveResetExecutionDecision(options: {
+    preflight: Awaited<ReturnType<typeof preflightReset>>;
+    provider: NonNullable<WalletResetExecutionOptions["provider"]>;
+    prompter: WalletResetExecutionOptions["prompter"];
+    paths: NonNullable<WalletResetExecutionOptions["paths"]>;
+}): Promise<ResetExecutionDecision>;
+export declare function determineWalletAction(walletPresent: boolean, walletChoice: ResetExecutionDecision["walletChoice"]): WalletResetAction;
+export declare function determineSnapshotResultStatus(options: {
+    snapshotStatus: Awaited<ReturnType<typeof preflightReset>>["snapshot"]["status"];
+    deleteSnapshot: boolean;
+}): WalletResetSnapshotResultStatus;
+export declare function determineBitcoinDataDirResultStatus(options: {
+    bitcoinDataDirStatus: Awaited<ReturnType<typeof preflightReset>>["bitcoinDataDir"]["status"];
+    deleteSnapshot: boolean;
+    deleteBitcoinDataDir: boolean;
+}): WalletResetBitcoinDataDirResultStatus;
+export declare function resetWallet(options: WalletResetExecutionOptions): Promise<WalletResetResult>;