@cogcoin/client 0.5.14 → 1.0.0

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

@@ -54,6 +54,19 @@ async function setBitcoinSyncProgress(dependencies, info, targetHeightCap) {
             : "Reading blocks from the managed Bitcoin node.",
     });
 }
+function isMissingBlockRecordError(error) {
+    return error instanceof Error && error.message.startsWith("client_store_missing_block_record_");
+}
+async function setDeepRecoveryProgress(dependencies, blocks, bestHeight, message) {
+    await dependencies.progress.setPhase("cogcoin_sync", {
+        blocks,
+        headers: bestHeight,
+        targetHeight: bestHeight,
+        etaSeconds: estimateEtaSeconds(dependencies.cogcoinRateTracker, blocks, bestHeight),
+        lastError: null,
+        message,
+    });
+}
 function resolveIndexedHeightForReplayWindow(tip, startHeight) {
     return tip?.height ?? (startHeight - 1);
 }
@@ -100,20 +113,50 @@ async function runWithManagedRpcRetry(dependencies, retryState, operation) {
     }
 }
 async function findCommonAncestor(dependencies, tip, bestHeight, runRpc) {
-    const startHeight = Math.min(tip.height, bestHeight);
-    for (let height = startHeight; height >= dependencies.startHeight; height -= 1) {
+    const searchStartHeight = Math.min(tip.height, bestHeight);
+    for (let height = searchStartHeight; height >= dependencies.startHeight; height -= 1) {
         const localHashHex = height === tip.height
             ? tip.blockHashHex
             : (await dependencies.store.loadBlockRecord(height))?.blockHashHex ?? null;
         if (localHashHex === null) {
-            continue;
+            return {
+                kind: "checkpoint_recovery",
+            };
         }
         const chainHashHex = await runRpc(() => dependencies.rpc.getBlockHash(height));
         if (chainHashHex === localHashHex) {
-            return height;
+            return {
+                kind: "rewind",
+                rewindTarget: height,
+            };
         }
     }
-    return dependencies.startHeight - 1;
+    return {
+        kind: "rewind",
+        rewindTarget: dependencies.startHeight - 1,
+    };
+}
+async function recoverFromCheckpoint(dependencies, startTip, bestHeight, runRpc) {
+    let checkpoint = await dependencies.store.loadLatestCheckpointAtOrBelow(Math.min(startTip.height, bestHeight));
+    while (checkpoint !== null) {
+        const currentCheckpoint = checkpoint;
+        const chainHashHex = await runRpc(() => dependencies.rpc.getBlockHash(currentCheckpoint.height));
+        if (chainHashHex === currentCheckpoint.blockHashHex) {
+            await setDeepRecoveryProgress(dependencies, currentCheckpoint.height, bestHeight, `Retained rewind window exhausted; restoring checkpoint at height ${currentCheckpoint.height.toLocaleString()} and replaying.`);
+            await dependencies.client.restoreCheckpoint(currentCheckpoint);
+            return {
+                rewoundBlocks: startTip.height - currentCheckpoint.height,
+                commonAncestorHeight: currentCheckpoint.height,
+            };
+        }
+        checkpoint = await dependencies.store.loadLatestCheckpointAtOrBelow(currentCheckpoint.height - 1);
+    }
+    await setDeepRecoveryProgress(dependencies, Math.max(0, dependencies.startHeight - 1), bestHeight, "Retained rewind window exhausted; resetting to the processing start and replaying.");
+    await dependencies.client.resetToInitialState();
+    return {
+        rewoundBlocks: startTip.height - dependencies.startHeight + 1,
+        commonAncestorHeight: null,
+    };
 }
 async function syncAgainstBestHeight(dependencies, bestHeight, runRpc) {
     if (bestHeight < dependencies.startHeight) {
@@ -127,11 +170,26 @@ async function syncAgainstBestHeight(dependencies, bestHeight, runRpc) {
     let rewoundBlocks = 0;
     let commonAncestorHeight = null;
     if (startTip !== null) {
-        const rewindTarget = await findCommonAncestor(dependencies, startTip, bestHeight, runRpc);
-        if (rewindTarget < startTip.height) {
-            commonAncestorHeight = rewindTarget < dependencies.startHeight ? null : rewindTarget;
-            await dependencies.client.rewindToHeight(rewindTarget);
-            rewoundBlocks = startTip.height - rewindTarget;
+        const ancestor = await findCommonAncestor(dependencies, startTip, bestHeight, runRpc);
+        if (ancestor.kind === "checkpoint_recovery") {
+            const recovered = await recoverFromCheckpoint(dependencies, startTip, bestHeight, runRpc);
+            rewoundBlocks = recovered.rewoundBlocks;
+            commonAncestorHeight = recovered.commonAncestorHeight;
+        }
+        else if (ancestor.rewindTarget < startTip.height) {
+            try {
+                commonAncestorHeight = ancestor.rewindTarget < dependencies.startHeight ? null : ancestor.rewindTarget;
+                await dependencies.client.rewindToHeight(ancestor.rewindTarget);
+                rewoundBlocks = startTip.height - ancestor.rewindTarget;
+            }
+            catch (error) {
+                if (!isMissingBlockRecordError(error)) {
+                    throw error;
+                }
+                const recovered = await recoverFromCheckpoint(dependencies, startTip, bestHeight, runRpc);
+                rewoundBlocks = recovered.rewoundBlocks;
+                commonAncestorHeight = recovered.commonAncestorHeight;
+            }
         }
     }
     const tipAfterRewind = await dependencies.client.getTip();
@@ -165,6 +223,7 @@ export async function syncToTip(dependencies) {
         const runRpc = (operation) => runWithManagedRpcRetry(dependencies, retryState, operation);
         throwIfAborted(dependencies.abortSignal);
         await runRpc(() => dependencies.node.validate());
+        await dependencies.bootstrap.cleanupObsoleteSnapshotFilesIfNeeded().catch(() => false);
         const indexedTipBeforeBootstrap = await dependencies.client.getTip();
         await runRpc(() => dependencies.bootstrap.ensureReady(indexedTipBeforeBootstrap, dependencies.node.expectedChain, {
             signal: dependencies.abortSignal,
@@ -219,6 +278,7 @@ export async function syncToTip(dependencies) {
                 && dependencies.targetHeightCap !== undefined
                 && endBestHeight >= dependencies.targetHeightCap;
             if (reachedTargetHeightCap && caughtUpCogcoin) {
+                await dependencies.bootstrap.cleanupObsoleteSnapshotFilesIfNeeded().catch(() => false);
                 return aggregate;
             }
             if (dependencies.targetHeightCap === null
@@ -234,8 +294,9 @@ export async function syncToTip(dependencies) {
                     lastError: null,
                     message: dependencies.isFollowing()
                         ? "Following the live Bitcoin tip."
-                        : "Managed sync fully caught up to the live tip.",
+                        : "Sync complete.",
                 });
+                await dependencies.bootstrap.cleanupObsoleteSnapshotFilesIfNeeded().catch(() => false);
                 return aggregate;
             }
             if (endBestHeight >= dependencies.startHeight && finalTip?.height !== endBestHeight) {

package/dist/bitcoind/hash-order.d.ts

@@ -0,0 +1,4 @@
+export declare function displayHashHexToInternalBytes(hashHex: string): Uint8Array;
+export declare function displayHashHexToInternalHex(hashHex: string): string;
+export declare function internalBytesToDisplayHashHex(hash: Uint8Array): string;
+export declare function internalHashHexToDisplayHashHex(hashHex: string): string;

package/dist/bitcoind/hash-order.js

@@ -0,0 +1,13 @@
+import { bytesToHex, hexToBytes, reverseBytes } from "../bytes.js";
+export function displayHashHexToInternalBytes(hashHex) {
+    return reverseBytes(hexToBytes(hashHex));
+}
+export function displayHashHexToInternalHex(hashHex) {
+    return bytesToHex(displayHashHexToInternalBytes(hashHex));
+}
+export function internalBytesToDisplayHashHex(hash) {
+    return bytesToHex(reverseBytes(hash));
+}
+export function internalHashHexToDisplayHashHex(hashHex) {
+    return internalBytesToDisplayHashHex(hexToBytes(hashHex));
+}

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

@@ -1,12 +1,13 @@
 import { randomUUID } from "node:crypto";
 import net from "node:net";
 import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
-import { serializeIndexerState } from "@cogcoin/indexer";
+import { loadBundledGenesisParameters, serializeIndexerState } from "@cogcoin/indexer";
 import { openManagedBitcoindClientInternal } from "./client.js";
 import { openClient } from "../client.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
 import { createRpcClient } from "./node.js";
+import { normalizeCogcoinProcessingStartHeight } from "./processing-start-height.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
 import { INDEXER_DAEMON_SCHEMA_VERSION, INDEXER_DAEMON_SERVICE_API_VERSION, } from "./types.js";
 const SNAPSHOT_TTL_MS = 30_000;
@@ -156,6 +157,7 @@ async function main() {
     const paths = resolveManagedServicePaths(dataDir, walletRootId);
     const daemonInstanceId = randomUUID();
     const binaryVersion = await readPackageVersionFromDisk();
+    const genesisParameters = await loadBundledGenesisParameters();
     const startedAtUnixMs = Date.now();
     const snapshots = new Map();
     let state = "starting";
@@ -292,12 +294,18 @@ async function main() {
         backgroundResumePromise = (async () => {
             const bitcoindStatus = await readManagedBitcoindStatus(paths);
             const store = await openSqliteStore({ filename: databasePath });
+            const chain = bitcoindStatus?.chain ?? "main";
+            const startHeight = normalizeCogcoinProcessingStartHeight({
+                chain,
+                startHeight: bitcoindStatus?.startHeight,
+                genesisParameters,
+            });
             try {
                 const client = await openManagedBitcoindClientInternal({
                     store,
                     dataDir,
-                    chain: bitcoindStatus?.chain ?? "main",
-                    startHeight: bitcoindStatus?.startHeight ?? 0,
+                    chain,
+                    startHeight,
                     walletRootId,
                     progressOutput: "none",
                 });

package/dist/bitcoind/normalize.js

@@ -1,4 +1,5 @@
 import { hexToBytes } from "../bytes.js";
+import { displayHashHexToInternalBytes } from "./hash-order.js";
 function btcValueToSats(value) {
     const source = typeof value === "number"
         ? value.toFixed(8)
@@ -40,8 +41,8 @@ function normalizeTransaction(transaction) {
 export function normalizeRpcBlock(block) {
     return {
         height: block.height,
-        hash: hexToBytes(block.hash),
-        previousHash: block.previousblockhash ? hexToBytes(block.previousblockhash) : null,
+        hash: displayHashHexToInternalBytes(block.hash),
+        previousHash: block.previousblockhash ? displayHashHexToInternalBytes(block.previousblockhash) : null,
         transactions: block.tx.map(normalizeTransaction),
     };
 }

package/dist/bitcoind/processing-start-height.d.ts

@@ -1,5 +1,10 @@
 import type { GenesisParameters } from "@cogcoin/indexer/types";
 export declare function resolveCogcoinProcessingStartHeight(genesisParameters: GenesisParameters): number;
+export declare function normalizeCogcoinProcessingStartHeight(options: {
+    chain: "main" | "regtest";
+    startHeight: number | null | undefined;
+    genesisParameters: GenesisParameters;
+}): number;
 export declare function assertCogcoinProcessingStartHeight(options: {
     chain: "main" | "regtest";
     startHeight: number;

package/dist/bitcoind/processing-start-height.js

@@ -1,6 +1,13 @@
 export function resolveCogcoinProcessingStartHeight(genesisParameters) {
     return genesisParameters.genesisBlock;
 }
+export function normalizeCogcoinProcessingStartHeight(options) {
+    if (options.chain !== "main") {
+        return options.startHeight ?? 0;
+    }
+    const processingStartHeight = resolveCogcoinProcessingStartHeight(options.genesisParameters);
+    return Math.max(options.startHeight ?? processingStartHeight, processingStartHeight);
+}
 export function assertCogcoinProcessingStartHeight(options) {
     const processingStartHeight = resolveCogcoinProcessingStartHeight(options.genesisParameters);
     if (options.chain === "main" && options.startHeight < processingStartHeight) {

package/dist/bitcoind/progress/constants.d.ts

@@ -7,6 +7,10 @@ export declare const INTRO_ENTRY_MS = 5000;
 export declare const INTRO_PAUSE_MS = 5000;
 export declare const INTRO_EXIT_MS = 5000;
 export declare const INTRO_TOTAL_MS: number;
+export declare const COMPLETION_ENTRY_MS = 5000;
+export declare const COMPLETION_PAUSE_MS = 5000;
+export declare const COMPLETION_EXIT_MS = 0;
+export declare const COMPLETION_TOTAL_MS: number;
 export declare const STATUS_ELLIPSIS_WIDTH = 3;
 export declare const STATUS_ELLIPSIS_TICK_MS = 500;
 export declare const NEUTRAL_MESSAGE_TITLE = "\u26ED  C O G C O I N  \u26ED";

package/dist/bitcoind/progress/constants.js

@@ -7,6 +7,10 @@ export const INTRO_ENTRY_MS = 5_000;
 export const INTRO_PAUSE_MS = 5_000;
 export const INTRO_EXIT_MS = 5_000;
 export const INTRO_TOTAL_MS = INTRO_ENTRY_MS + INTRO_PAUSE_MS + INTRO_EXIT_MS;
+export const COMPLETION_ENTRY_MS = INTRO_ENTRY_MS;
+export const COMPLETION_PAUSE_MS = INTRO_PAUSE_MS;
+export const COMPLETION_EXIT_MS = 0;
+export const COMPLETION_TOTAL_MS = COMPLETION_ENTRY_MS + COMPLETION_PAUSE_MS + COMPLETION_EXIT_MS;
 export const STATUS_ELLIPSIS_WIDTH = 3;
 export const STATUS_ELLIPSIS_TICK_MS = 500;
 export const NEUTRAL_MESSAGE_TITLE = "⛭  C O G C O I N  ⛭";

package/dist/bitcoind/progress/controller.d.ts

@@ -2,6 +2,7 @@ import type { QuoteDisplayPhase } from "../quotes.js";
 import type { BootstrapPhase, BootstrapProgress, ManagedBitcoindProgressEvent, ProgressOutputMode, SnapshotMetadata, WritingQuote } from "../types.js";
 import { type FollowSceneStateForTesting } from "./follow-scene.js";
 import { type RenderClock, type TtyRenderStream } from "./render-policy.js";
+import { type FollowSceneRenderOptions } from "./tty-renderer.js";
 interface QuoteRotatorLike {
     current(now?: number): Promise<{
         displayPhase: QuoteDisplayPhase;
@@ -12,7 +13,7 @@ interface QuoteRotatorLike {
 interface ProgressRendererLike {
     render(displayPhase: QuoteDisplayPhase, quote: WritingQuote | null, progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, introElapsedMs?: number, statusFieldText?: string): void;
     renderTrainScene(kind: "intro" | "completion", progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, elapsedMs: number, statusFieldText?: string): void;
-    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: FollowSceneStateForTesting, statusFieldText?: string): void;
+    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: FollowSceneStateForTesting, statusFieldText?: string, renderOptions?: FollowSceneRenderOptions): void;
     close(): void;
 }
 interface ProgressControllerOptions {

package/dist/bitcoind/progress/controller.js

@@ -1,5 +1,5 @@
 import { WritingQuoteRotator as QuoteRotator } from "../quotes.js";
-import { INTRO_TOTAL_MS } from "./constants.js";
+import { COMPLETION_TOTAL_MS } from "./constants.js";
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, setFollowBlockTime, syncFollowSceneState, } from "./follow-scene.js";
 import { createBootstrapProgress, createDefaultMessage, resolveStatusFieldText, } from "./formatting.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "./render-policy.js";
@@ -105,9 +105,9 @@ export class ManagedProgressController {
         }
         const startedAt = this.#clock.now();
         while (true) {
-            const elapsedMs = Math.min(INTRO_TOTAL_MS, this.#clock.now() - startedAt);
+            const elapsedMs = Math.min(COMPLETION_TOTAL_MS, this.#clock.now() - startedAt);
             this.#renderer.renderTrainScene("completion", this.#progress, this.#cogcoinSyncHeight, this.#cogcoinSyncTargetHeight, elapsedMs);
-            if (elapsedMs >= INTRO_TOTAL_MS) {
+            if (elapsedMs >= COMPLETION_TOTAL_MS) {
                 break;
             }
             await new Promise((resolve) => {

package/dist/bitcoind/progress/follow-scene.d.ts

@@ -16,6 +16,10 @@ export interface FollowSceneStateForTesting {
     pendingStaticX: number | null;
     animation: FollowAnimation | null;
 }
+export interface FollowFrameRenderOptions {
+    artworkCogText?: string | null;
+    artworkSatText?: string | null;
+}
 export declare function createFollowSceneState(indexedHeight?: number | null, blockTimesByHeight?: Record<number, number>): FollowSceneStateForTesting;
 export declare function setFollowBlockTime(state: FollowSceneStateForTesting, height: number, blockTime: number): void;
 export declare function replaceFollowBlockTimes(state: FollowSceneStateForTesting, blockTimesByHeight: Record<number, number>): void;
@@ -27,7 +31,7 @@ export declare function syncFollowSceneState(state: FollowSceneStateForTesting,
     liveActivated?: boolean;
 }): void;
 export declare function advanceFollowSceneState(state: FollowSceneStateForTesting, now: number): void;
-export declare function renderFollowFrame(state: FollowSceneStateForTesting, statusFieldText: string, now: number): string[];
+export declare function renderFollowFrame(state: FollowSceneStateForTesting, statusFieldText: string, now: number, options?: FollowFrameRenderOptions): string[];
 export declare function createFollowSceneStateForTesting(indexedHeight?: number | null, blockTimesByHeight?: Record<number, number>): FollowSceneStateForTesting;
 export declare function setFollowBlockTimesForTesting(state: FollowSceneStateForTesting, blockTimesByHeight: Record<number, number>): FollowSceneStateForTesting;
 export declare function setFollowBlockTimeForTesting(state: FollowSceneStateForTesting, height: number, blockTime: number): FollowSceneStateForTesting;
@@ -37,4 +41,4 @@ export declare function syncFollowSceneStateForTesting(state: FollowSceneStateFo
     liveActivated?: boolean;
 }): FollowSceneStateForTesting;
 export declare function advanceFollowSceneStateForTesting(state: FollowSceneStateForTesting, now: number): FollowSceneStateForTesting;
-export declare function renderFollowFrameForTesting(state: FollowSceneStateForTesting, statusFieldText?: string, now?: number): string[];
+export declare function renderFollowFrameForTesting(state: FollowSceneStateForTesting, statusFieldText?: string, now?: number, options?: FollowFrameRenderOptions): string[];

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

@@ -1,6 +1,12 @@
 import { loadArtTemplate, loadFollowCarTemplate } from "./assets.js";
-import { FOLLOW_AGE_ROW, FOLLOW_APPROACH_MS, FOLLOW_CAR_HEIGHT, FOLLOW_CAR_PITCH, FOLLOW_CAR_TOP, FOLLOW_CAR_WIDTH, FOLLOW_CENTER_SLOT_X, FOLLOW_CLIP_MAX_COLUMN, FOLLOW_CLIP_MIN_COLUMN, FOLLOW_CONNECTION_SLOT_X, FOLLOW_FAST_APPROACH_MS, FOLLOW_FAST_SHIFT_MS, FOLLOW_PENDING_ENTER_MS, FOLLOW_PENDING_LABEL, FOLLOW_PENDING_OFFSCREEN_LEFT_X, FOLLOW_PENDING_SLOT_X, FOLLOW_RIGHT_SLOT_XS, FOLLOW_SHIFT_MS, FOLLOW_WINDOW_LEFT, MESSAGE_FIELD_ROW, NEUTRAL_MESSAGE_TITLE, STATUS_FIELD_ROW, } from "./constants.js";
-import { centerLine, overlayCenteredField } from "./formatting.js";
+import { FIELD_LEFT, FIELD_WIDTH, FOLLOW_AGE_ROW, FOLLOW_APPROACH_MS, FOLLOW_CAR_HEIGHT, FOLLOW_CAR_PITCH, FOLLOW_CAR_TOP, FOLLOW_CAR_WIDTH, FOLLOW_CENTER_SLOT_X, FOLLOW_CLIP_MAX_COLUMN, FOLLOW_CLIP_MIN_COLUMN, FOLLOW_CONNECTION_SLOT_X, FOLLOW_FAST_APPROACH_MS, FOLLOW_FAST_SHIFT_MS, FOLLOW_PENDING_ENTER_MS, FOLLOW_PENDING_LABEL, FOLLOW_PENDING_OFFSCREEN_LEFT_X, FOLLOW_PENDING_SLOT_X, FOLLOW_RIGHT_SLOT_XS, FOLLOW_SHIFT_MS, FOLLOW_WINDOW_LEFT, MESSAGE_FIELD_ROW, NEUTRAL_MESSAGE_TITLE, STATUS_FIELD_ROW, } from "./constants.js";
+import { centerLine, computeCenteredLeftPadding, overlayCenteredField, replaceSegment, rightAlignLine, truncateLine, } from "./formatting.js";
+const FOLLOW_TITLE_LEFT = computeCenteredLeftPadding(NEUTRAL_MESSAGE_TITLE, FIELD_WIDTH);
+const FOLLOW_TITLE_WIDTH = NEUTRAL_MESSAGE_TITLE.length;
+const FOLLOW_COG_LEFT = 0;
+const FOLLOW_COG_WIDTH = FOLLOW_TITLE_LEFT;
+const FOLLOW_SAT_LEFT = FOLLOW_TITLE_LEFT + FOLLOW_TITLE_WIDTH;
+const FOLLOW_SAT_WIDTH = FIELD_WIDTH - FOLLOW_SAT_LEFT;
 export function createFollowSceneState(indexedHeight = null, blockTimesByHeight = {}) {
     return {
         liveActivated: false,
@@ -59,6 +65,20 @@ export function formatCompactFollowAgeLabel(blockTime, now) {
     return `${Math.floor(elapsedHours / 24)}d`;
 }
 export const formatCompactFollowAgeLabelForTesting = formatCompactFollowAgeLabel;
+function leftAlignLane(line, width) {
+    const aligned = truncateLine(line, width);
+    return aligned.padEnd(width, " ");
+}
+function renderFollowHeaderField(options) {
+    let field = centerLine(NEUTRAL_MESSAGE_TITLE, FIELD_WIDTH);
+    if (options.artworkCogText !== null && options.artworkCogText !== undefined && options.artworkCogText.length > 0) {
+        field = replaceSegment(field, FOLLOW_COG_LEFT, FOLLOW_COG_WIDTH, leftAlignLane(options.artworkCogText, FOLLOW_COG_WIDTH));
+    }
+    if (options.artworkSatText !== null && options.artworkSatText !== undefined && options.artworkSatText.length > 0) {
+        field = replaceSegment(field, FOLLOW_SAT_LEFT, FOLLOW_SAT_WIDTH, rightAlignLine(options.artworkSatText, FOLLOW_SAT_WIDTH));
+    }
+    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);
 }
@@ -327,7 +347,7 @@ function resolveFollowCarPlacements(state, now) {
     }
     return placements;
 }
-export function renderFollowFrame(state, statusFieldText, now) {
+export function renderFollowFrame(state, statusFieldText, now, options = {}) {
     let frame = createFollowBaseFrame();
     const placements = resolveFollowCarPlacements(state, now);
     for (const car of placements) {
@@ -339,7 +359,10 @@ export function renderFollowFrame(state, statusFieldText, now) {
             frame = overlayFollowAgeLabel(frame, car, ageLabel);
         }
     }
-    overlayCenteredField(frame, MESSAGE_FIELD_ROW, NEUTRAL_MESSAGE_TITLE);
+    const headerRow = frame[MESSAGE_FIELD_ROW];
+    if (headerRow !== undefined) {
+        frame[MESSAGE_FIELD_ROW] = replaceSegment(headerRow, FIELD_LEFT, FIELD_WIDTH, renderFollowHeaderField(options));
+    }
     overlayCenteredField(frame, STATUS_FIELD_ROW, statusFieldText);
     return frame;
 }
@@ -362,6 +385,6 @@ export function advanceFollowSceneStateForTesting(state, now) {
     advanceFollowSceneState(state, now);
     return cloneFollowSceneState(state);
 }
-export function renderFollowFrameForTesting(state, statusFieldText = "", now = 0) {
-    return renderFollowFrame(state, statusFieldText, now);
+export function renderFollowFrameForTesting(state, statusFieldText = "", now = 0, options = {}) {
+    return renderFollowFrame(state, statusFieldText, now, options);
 }

package/dist/bitcoind/progress/formatting.d.ts

@@ -9,6 +9,7 @@ export declare function renderIndeterminateBar(width: number, now: number): stri
 export declare function truncateLine(line: string, width: number): string;
 export declare function normalizeInlineText(value: string): string;
 export declare function centerLine(line: string, width: number): string;
+export declare function rightAlignLine(line: string, width: number): string;
 export declare function positionLine(line: string, width: number, leftPadding: number): string;
 export declare function computeCenteredLeftPadding(line: string, width: number): number;
 export declare function centerFieldText(text: string): string;

package/dist/bitcoind/progress/formatting.js

@@ -102,6 +102,11 @@ export function centerLine(line, width) {
     const leftPadding = Math.max(0, Math.floor((width - centered.length) / 2));
     return `${" ".repeat(leftPadding)}${centered}`.padEnd(width, " ");
 }
+export function rightAlignLine(line, width) {
+    const aligned = truncateLine(line, width);
+    const leftPadding = Math.max(0, width - aligned.length);
+    return `${" ".repeat(leftPadding)}${aligned}`.padEnd(width, " ");
+}
 export function positionLine(line, width, leftPadding) {
     const positioned = truncateLine(line, width);
     const safePadding = Math.max(0, Math.min(leftPadding, Math.max(0, width - positioned.length)));
@@ -130,6 +135,7 @@ export function resolveStatusFieldText(progress, snapshotHeight, now = 0) {
         case "getblock_archive_import":
             return `Importing getblock range${animateStatusEllipsis(now)}`;
         case "paused":
+            return `Waiting to start managed sync${animateStatusEllipsis(now)}`;
         case "snapshot_download":
             return `Downloading snapshot to ${snapshotHeight}${animateStatusEllipsis(now)}`;
         case "wait_headers_for_snapshot":

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

@@ -1,18 +1,34 @@
-import { INTRO_ENTRY_MS, INTRO_EXIT_MS, INTRO_PAUSE_MS, INTRO_TOTAL_MS, MESSAGE_FIELD_ROW, NEUTRAL_MESSAGE_TITLE, SCROLL_WINDOW_LEFT, STATUS_FIELD_ROW, TRAIN_CENTER_X, TRAIN_CLIP_MAX_COLUMN, TRAIN_CLIP_MIN_COLUMN, TRAIN_OFFSCREEN_LEFT_X, TRAIN_OFFSCREEN_RIGHT_X, TRAIN_SPRITE_TOP, } from "./constants.js";
+import { COMPLETION_ENTRY_MS, COMPLETION_EXIT_MS, COMPLETION_PAUSE_MS, COMPLETION_TOTAL_MS, INTRO_ENTRY_MS, INTRO_EXIT_MS, INTRO_PAUSE_MS, INTRO_TOTAL_MS, MESSAGE_FIELD_ROW, NEUTRAL_MESSAGE_TITLE, SCROLL_WINDOW_LEFT, STATUS_FIELD_ROW, TRAIN_CENTER_X, TRAIN_CLIP_MAX_COLUMN, TRAIN_CLIP_MIN_COLUMN, TRAIN_OFFSCREEN_LEFT_X, TRAIN_OFFSCREEN_RIGHT_X, TRAIN_SPRITE_TOP, } from "./constants.js";
 import { loadArtTemplate, loadSprite } from "./assets.js";
 import { overlayCenteredField } from "./formatting.js";
+function resolveTrainSceneTimings(kind) {
+    return kind === "intro"
+        ? {
+            entryMs: INTRO_ENTRY_MS,
+            pauseMs: INTRO_PAUSE_MS,
+            exitMs: INTRO_EXIT_MS,
+            totalMs: INTRO_TOTAL_MS,
+        }
+        : {
+            entryMs: COMPLETION_ENTRY_MS,
+            pauseMs: COMPLETION_PAUSE_MS,
+            exitMs: COMPLETION_EXIT_MS,
+            totalMs: COMPLETION_TOTAL_MS,
+        };
+}
 export function resolveTrainSceneMessage(kind, elapsedMs) {
-    if (elapsedMs < INTRO_ENTRY_MS) {
+    const timings = resolveTrainSceneTimings(kind);
+    if (elapsedMs < timings.entryMs) {
         return kind === "intro"
             ? "Here comes the mining train!"
             : "Congratuations, you are synced!";
     }
-    if (elapsedMs < INTRO_ENTRY_MS + INTRO_PAUSE_MS) {
+    if (elapsedMs < timings.entryMs + timings.pauseMs || kind === "completion") {
         return kind === "intro"
             ? "Welcome to Cogcoin!"
             : "You shape your own future.";
     }
-    if (elapsedMs < INTRO_TOTAL_MS) {
+    if (elapsedMs < timings.totalMs) {
         return kind === "intro"
             ? "How many sentences will you mine?"
             : "Your Cogcoin story begins...";
@@ -25,25 +41,27 @@ export function resolveIntroMessageForTesting(introElapsedMs) {
 export function resolveCompletionMessageForTesting(completionElapsedMs) {
     return resolveTrainSceneMessage("completion", completionElapsedMs);
 }
-function resolveIntroSpriteName(introElapsedMs) {
-    if (introElapsedMs >= INTRO_ENTRY_MS && introElapsedMs < INTRO_ENTRY_MS + INTRO_PAUSE_MS) {
+function resolveTrainSpriteName(kind, elapsedMs) {
+    const timings = resolveTrainSceneTimings(kind);
+    if (elapsedMs >= timings.entryMs && (kind === "completion" || elapsedMs < timings.entryMs + timings.pauseMs)) {
         return "train";
     }
     return "train-smoke";
 }
-function resolveIntroSpriteX(introElapsedMs) {
-    if (introElapsedMs <= 0) {
+function resolveTrainSpriteX(kind, elapsedMs) {
+    const timings = resolveTrainSceneTimings(kind);
+    if (elapsedMs <= 0) {
         return TRAIN_OFFSCREEN_RIGHT_X;
     }
-    if (introElapsedMs < INTRO_ENTRY_MS) {
-        const progress = introElapsedMs / INTRO_ENTRY_MS;
+    if (elapsedMs < timings.entryMs) {
+        const progress = elapsedMs / timings.entryMs;
         return Math.round(TRAIN_OFFSCREEN_RIGHT_X + ((TRAIN_CENTER_X - TRAIN_OFFSCREEN_RIGHT_X) * progress));
     }
-    if (introElapsedMs < INTRO_ENTRY_MS + INTRO_PAUSE_MS) {
+    if (kind === "completion" || elapsedMs < timings.entryMs + timings.pauseMs) {
         return TRAIN_CENTER_X;
     }
-    if (introElapsedMs < INTRO_TOTAL_MS) {
-        const progress = (introElapsedMs - INTRO_ENTRY_MS - INTRO_PAUSE_MS) / INTRO_EXIT_MS;
+    if (elapsedMs < timings.totalMs) {
+        const progress = (elapsedMs - timings.entryMs - timings.pauseMs) / timings.exitMs;
         return Math.round(TRAIN_CENTER_X + ((TRAIN_OFFSCREEN_LEFT_X - TRAIN_CENTER_X) * progress));
     }
     return TRAIN_OFFSCREEN_LEFT_X;
@@ -70,13 +88,14 @@ function overlaySpriteOnFrame(frame, sprite, spriteX) {
 }
 export function renderTrainSceneFrame(kind, elapsedMs, statusFieldText) {
     const frame = [...loadArtTemplate("scroll")];
-    const introFrame = elapsedMs >= INTRO_TOTAL_MS
+    const timings = resolveTrainSceneTimings(kind);
+    const renderedFrame = kind === "intro" && elapsedMs >= timings.totalMs
         ? frame
-        : overlaySpriteOnFrame(frame, loadSprite(resolveIntroSpriteName(elapsedMs)), resolveIntroSpriteX(elapsedMs));
+        : overlaySpriteOnFrame(frame, loadSprite(resolveTrainSpriteName(kind, elapsedMs)), resolveTrainSpriteX(kind, elapsedMs));
     const message = resolveTrainSceneMessage(kind, elapsedMs);
-    overlayCenteredField(introFrame, MESSAGE_FIELD_ROW, message.length > 0 ? message : NEUTRAL_MESSAGE_TITLE);
-    overlayCenteredField(introFrame, STATUS_FIELD_ROW, statusFieldText);
-    return introFrame;
+    overlayCenteredField(renderedFrame, MESSAGE_FIELD_ROW, message.length > 0 ? message : NEUTRAL_MESSAGE_TITLE);
+    overlayCenteredField(renderedFrame, STATUS_FIELD_ROW, statusFieldText);
+    return renderedFrame;
 }
 export function renderIntroFrame(introElapsedMs, statusFieldText) {
     return renderTrainSceneFrame("intro", introElapsedMs, statusFieldText);

package/dist/bitcoind/progress/tty-renderer.d.ts

@@ -7,12 +7,17 @@ interface RenderStream {
     columns?: number;
     write(chunk: string): boolean | void;
 }
+export interface FollowSceneRenderOptions {
+    artworkCogText?: string | null;
+    artworkSatText?: string | null;
+    extraLines?: string[];
+}
 export declare class TtyProgressRenderer {
     #private;
     constructor(stream?: RenderStream);
     render(displayPhase: QuoteDisplayPhase, quote: WritingQuote | null, progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, introElapsedMs?: number, statusFieldText?: string): void;
     renderTrainScene(kind: TrainSceneKind, progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, elapsedMs: number, statusFieldText?: string): void;
-    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: FollowSceneStateForTesting, statusFieldText?: string): void;
+    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: FollowSceneStateForTesting, statusFieldText?: string, renderOptions?: FollowSceneRenderOptions): void;
     close(): void;
 }
 export {};

package/dist/bitcoind/progress/tty-renderer.js

@@ -1,4 +1,4 @@
-import { ART_WIDTH, INTRO_TOTAL_MS, NEUTRAL_MESSAGE_TITLE } from "./constants.js";
+import { ART_WIDTH, NEUTRAL_MESSAGE_TITLE } from "./constants.js";
 import { renderFollowFrame } from "./follow-scene.js";
 import { formatProgressLine, formatQuoteLine, truncateLine } from "./formatting.js";
 import { renderArtFrame } from "./quote-scene.js";
@@ -85,13 +85,17 @@ export class TtyProgressRenderer {
         this.#writeChunk(frame);
         this.#previousFrameHeight = lines.length;
     }
-    renderFollowScene(progress, cogcoinSyncHeight, cogcoinSyncTargetHeight, followScene, statusFieldText = "") {
+    renderFollowScene(progress, cogcoinSyncHeight, cogcoinSyncTargetHeight, followScene, statusFieldText = "", renderOptions = {}) {
         const now = Date.now();
         const width = Math.max(20, this.#stream.columns ?? 120);
         const progressLine = formatProgressLine(progress, cogcoinSyncHeight, cogcoinSyncTargetHeight, width, now);
+        const extraLines = (renderOptions.extraLines ?? []).map((line) => truncateLine(line, width));
         const lines = width >= ART_WIDTH
-            ? [...renderFollowFrame(followScene, statusFieldText, now), "", progressLine, ""]
-            : [truncateLine(NEUTRAL_MESSAGE_TITLE, width), progressLine, ""];
+            ? [...renderFollowFrame(followScene, statusFieldText, now, {
+                    artworkCogText: renderOptions.artworkCogText ?? null,
+                    artworkSatText: renderOptions.artworkSatText ?? null,
+                }), "", progressLine, "", ...extraLines]
+            : [truncateLine(NEUTRAL_MESSAGE_TITLE, width), progressLine, "", ...extraLines];
         const frame = lines.join("\n");
         this.#resetFrameIfExternalWritesDetected();
         if (!this.#rendered) {

package/dist/bitcoind/rpc.d.ts

@@ -1,4 +1,4 @@
-import type { RpcBlock, RpcBlockchainInfo, RpcChainStatesResponse, RpcCreateWalletResult, RpcDecodedPsbt, RpcDescriptorInfo, RpcFinalizePsbtResult, RpcImportDescriptorRequest, RpcImportDescriptorResult, RpcListUnspentEntry, RpcMempoolEntry, RpcMempoolInfo, RpcRawMempoolVerbose, RpcListDescriptorsResult, RpcLockedUnspent, RpcLoadTxOutSetResult, RpcLoadWalletResult, RpcNetworkInfo, RpcTestMempoolAcceptResult, RpcWalletInfo, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult, RpcTransaction, RpcWalletTransaction, RpcZmqNotification } from "./types.js";
+import type { RpcBlock, RpcBlockchainInfo, RpcChainStatesResponse, RpcCreateWalletResult, RpcDecodedPsbt, RpcDescriptorInfo, RpcEstimateSmartFeeResult, RpcFinalizePsbtResult, RpcImportDescriptorRequest, RpcImportDescriptorResult, RpcListUnspentEntry, RpcMempoolEntry, RpcMempoolInfo, RpcRawMempoolVerbose, RpcListDescriptorsResult, RpcLockedUnspent, RpcLoadTxOutSetResult, RpcLoadWalletResult, RpcNetworkInfo, RpcTestMempoolAcceptResult, RpcWalletInfo, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult, RpcTransaction, RpcWalletTransaction, RpcZmqNotification } from "./types.js";
 interface RpcRequestPayload {
     readonly body: string;
     readonly headers: Record<string, string>;
@@ -63,6 +63,7 @@ export declare class BitcoinRpcClient {
     getRawMempoolVerbose(): Promise<RpcRawMempoolVerbose>;
     getMempoolInfo(): Promise<RpcMempoolInfo>;
     getMempoolEntry(txid: string): Promise<RpcMempoolEntry>;
+    estimateSmartFee(confirmTarget: number, mode: "conservative" | "economical"): Promise<RpcEstimateSmartFeeResult>;
     saveMempool(): Promise<null>;
     getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
     getTransaction(walletName: string, txid: string): Promise<RpcWalletTransaction>;

package/dist/bitcoind/rpc.js

@@ -307,6 +307,9 @@ export class BitcoinRpcClient {
     getMempoolEntry(txid) {
         return this.call("getmempoolentry", [txid]);
     }
+    estimateSmartFee(confirmTarget, mode) {
+        return this.call("estimatesmartfee", [confirmTarget, mode]);
+    }
     saveMempool() {
         return this.call("savemempool");
     }