@cogcoin/client 0.5.8 → 0.5.10

package/dist/bitcoind/client/managed-client.js

@@ -1,7 +1,39 @@
+import { AssumeUtxoBootstrapController, deleteGetblockArchiveRange, prepareGetblockArchiveRange, } from "../bootstrap.js";
+import { createRpcClient } from "../node.js";
+import { attachOrStartManagedBitcoindService, stopManagedBitcoindService, } from "../service.js";
 import { closeFollowLoopResources, scheduleSync, startFollowingTipLoop } from "./follow-loop.js";
 import { loadVisibleFollowBlockTimes } from "./follow-block-times.js";
 import { createBlockRateTracker, createInitialSyncResult, } from "./internal-types.js";
 import { syncToTip as runManagedSync } from "./sync-engine.js";
+const GETBLOCK_RANGE_BASE_HEIGHT = 910_000;
+const GETBLOCK_RANGE_SIZE = 500;
+function isBoundaryHeight(height) {
+    return height >= GETBLOCK_RANGE_BASE_HEIGHT
+        && (height - GETBLOCK_RANGE_BASE_HEIGHT) % GETBLOCK_RANGE_SIZE === 0;
+}
+function resolveNextBoundary(height) {
+    if (height < GETBLOCK_RANGE_BASE_HEIGHT) {
+        return GETBLOCK_RANGE_BASE_HEIGHT;
+    }
+    if (isBoundaryHeight(height)) {
+        return height;
+    }
+    return GETBLOCK_RANGE_BASE_HEIGHT
+        + Math.ceil((height - GETBLOCK_RANGE_BASE_HEIGHT) / GETBLOCK_RANGE_SIZE) * GETBLOCK_RANGE_SIZE;
+}
+function mergeSyncResults(target, source) {
+    target.appliedBlocks += source.appliedBlocks;
+    target.rewoundBlocks += source.rewoundBlocks;
+    target.startingHeight = target.startingHeight ?? source.startingHeight;
+    target.endingHeight = source.endingHeight;
+    target.bestHeight = source.bestHeight;
+    target.bestHashHex = source.bestHashHex;
+    if (source.commonAncestorHeight !== null) {
+        target.commonAncestorHeight = target.commonAncestorHeight === null
+            ? source.commonAncestorHeight
+            : Math.min(target.commonAncestorHeight, source.commonAncestorHeight);
+    }
+}
 export class DefaultManagedBitcoindClient {
     #client;
     #store;
@@ -13,6 +45,11 @@ export class DefaultManagedBitcoindClient {
     #reattachIndexerDaemon;
     #startHeight;
     #syncDebounceMs;
+    #dataDir;
+    #walletRootId;
+    #startupTimeoutMs;
+    #shutdownTimeoutMs;
+    #fetchImpl;
     #following = false;
     #closed = false;
     #subscriber = null;
@@ -23,7 +60,7 @@ export class DefaultManagedBitcoindClient {
     #syncPromise = Promise.resolve(createInitialSyncResult());
     #debounceTimer = null;
     #syncAbortControllers = new Set();
-    constructor(client, store, node, rpc, progress, bootstrap, indexerDaemon, reattachIndexerDaemon, startHeight, syncDebounceMs) {
+    constructor(client, store, node, rpc, progress, bootstrap, indexerDaemon, reattachIndexerDaemon, startHeight, syncDebounceMs, dataDir, walletRootId, startupTimeoutMs, shutdownTimeoutMs, fetchImpl) {
         this.#client = client;
         this.#store = store;
         this.#node = node;
@@ -34,6 +71,11 @@ export class DefaultManagedBitcoindClient {
         this.#reattachIndexerDaemon = reattachIndexerDaemon;
         this.#startHeight = startHeight;
         this.#syncDebounceMs = syncDebounceMs;
+        this.#dataDir = dataDir;
+        this.#walletRootId = walletRootId;
+        this.#startupTimeoutMs = startupTimeoutMs;
+        this.#shutdownTimeoutMs = shutdownTimeoutMs;
+        this.#fetchImpl = fetchImpl;
     }
     async getTip() {
         return this.#client.getTip();
@@ -54,20 +96,10 @@ export class DefaultManagedBitcoindClient {
             const abortController = new AbortController();
             this.#syncAbortControllers.add(abortController);
             try {
-                return await runManagedSync({
-                    client: this.#client,
-                    store: this.#store,
-                    node: this.#node,
-                    rpc: this.#rpc,
-                    progress: this.#progress,
-                    bootstrap: this.#bootstrap,
-                    startHeight: this.#startHeight,
-                    bitcoinRateTracker: this.#bitcoinRateTracker,
-                    cogcoinRateTracker: this.#cogcoinRateTracker,
-                    abortSignal: abortController.signal,
-                    isFollowing: () => this.#following,
-                    loadVisibleFollowBlockTimes: (tip) => this.#loadVisibleFollowBlockTimes(tip),
-                });
+                if (this.#node.expectedChain !== "main") {
+                    return await this.#runManagedSyncPass(null, abortController.signal);
+                }
+                return await this.#syncWithStagedRanges(abortController.signal);
             }
             finally {
                 this.#syncAbortControllers.delete(abortController);
@@ -186,6 +218,134 @@ export class DefaultManagedBitcoindClient {
         this.#assertOpen();
         await this.#progress.playCompletionScene();
     }
+    async #syncWithStagedRanges(abortSignal) {
+        const aggregate = createInitialSyncResult();
+        let stagedModeEnabled = true;
+        await this.#ensureBootstrapReady(abortSignal);
+        while (stagedModeEnabled) {
+            const info = await this.#rpc.getBlockchainInfo();
+            if (info.blocks < GETBLOCK_RANGE_BASE_HEIGHT) {
+                break;
+            }
+            const nextBoundary = resolveNextBoundary(info.blocks);
+            if (nextBoundary === null) {
+                break;
+            }
+            if (!isBoundaryHeight(info.blocks)) {
+                mergeSyncResults(aggregate, await this.#runManagedSyncPass(nextBoundary, abortSignal));
+                continue;
+            }
+            const firstBlockHeight = info.blocks + 1;
+            const lastBlockHeight = info.blocks + GETBLOCK_RANGE_SIZE;
+            let readyRange;
+            try {
+                readyRange = await prepareGetblockArchiveRange({
+                    dataDir: this.#dataDir,
+                    progress: this.#progress,
+                    firstBlockHeight,
+                    lastBlockHeight,
+                    fetchImpl: this.#fetchImpl,
+                    signal: abortSignal,
+                });
+            }
+            catch {
+                stagedModeEnabled = false;
+                break;
+            }
+            if (readyRange === null) {
+                stagedModeEnabled = false;
+                break;
+            }
+            const stagedRestartActive = await this.#restartManagedNodeWithRange(readyRange, abortSignal);
+            mergeSyncResults(aggregate, await this.#runManagedSyncPass(lastBlockHeight, abortSignal));
+            if (stagedRestartActive) {
+                await deleteGetblockArchiveRange({
+                    dataDir: this.#dataDir,
+                    firstBlockHeight,
+                    lastBlockHeight,
+                }).catch(() => undefined);
+            }
+            else {
+                stagedModeEnabled = false;
+            }
+        }
+        mergeSyncResults(aggregate, await this.#runManagedSyncPass(null, abortSignal));
+        return aggregate;
+    }
+    async #runManagedSyncPass(targetHeightCap, abortSignal) {
+        return runManagedSync({
+            client: this.#client,
+            store: this.#store,
+            node: this.#node,
+            rpc: this.#rpc,
+            progress: this.#progress,
+            bootstrap: this.#bootstrap,
+            startHeight: this.#startHeight,
+            targetHeightCap,
+            bitcoinRateTracker: this.#bitcoinRateTracker,
+            cogcoinRateTracker: this.#cogcoinRateTracker,
+            abortSignal,
+            isFollowing: () => this.#following,
+            loadVisibleFollowBlockTimes: (tip) => this.#loadVisibleFollowBlockTimes(tip),
+        });
+    }
+    async #ensureBootstrapReady(signal) {
+        await this.#node.validate();
+        const indexedTipBeforeBootstrap = await this.#client.getTip();
+        await this.#bootstrap.ensureReady(indexedTipBeforeBootstrap, this.#node.expectedChain, { signal });
+    }
+    async #restartManagedNodeWithRange(readyRange, abortSignal) {
+        if (abortSignal.aborted) {
+            throw abortSignal.reason instanceof Error ? abortSignal.reason : new Error("managed_sync_aborted");
+        }
+        const baseOptions = {
+            chain: this.#node.expectedChain,
+            startHeight: this.#node.startHeight,
+            dataDir: this.#dataDir,
+            walletRootId: this.#walletRootId,
+            startupTimeoutMs: this.#startupTimeoutMs,
+            shutdownTimeoutMs: this.#shutdownTimeoutMs,
+        };
+        try {
+            await stopManagedBitcoindService({
+                dataDir: this.#dataDir,
+                walletRootId: this.#walletRootId,
+                shutdownTimeoutMs: this.#shutdownTimeoutMs,
+            });
+            const node = await attachOrStartManagedBitcoindService({
+                ...baseOptions,
+                getblockArchivePath: readyRange.artifactPath,
+                getblockArchiveEndHeight: readyRange.manifest.lastBlockHeight,
+                getblockArchiveSha256: readyRange.manifest.artifactSha256,
+            });
+            await this.#replaceManagedBindings(node);
+            return true;
+        }
+        catch {
+            const node = await attachOrStartManagedBitcoindService({
+                ...baseOptions,
+                getblockArchivePath: null,
+                getblockArchiveEndHeight: null,
+                getblockArchiveSha256: null,
+            });
+            await this.#replaceManagedBindings(node);
+            return false;
+        }
+    }
+    async #replaceManagedBindings(node) {
+        this.#node = node;
+        this.#rpc = createRpcClient(node.rpc);
+        this.#bootstrap = new AssumeUtxoBootstrapController({
+            rpc: this.#rpc,
+            dataDir: node.dataDir,
+            progress: this.#progress,
+            snapshot: this.#progress.getStatusSnapshot().snapshot,
+        });
+        if (this.#subscriber !== null) {
+            this.#subscriber.connect(node.zmq.endpoint);
+            this.#subscriber.subscribe(node.zmq.topic);
+        }
+    }
     #scheduleSync() {
         scheduleSync({
             syncDebounceMs: this.#syncDebounceMs,

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

@@ -39,12 +39,13 @@ function sleep(ms, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-async function setBitcoinSyncProgress(dependencies, info) {
-    const etaSeconds = estimateEtaSeconds(dependencies.bitcoinRateTracker, info.blocks, info.headers);
+async function setBitcoinSyncProgress(dependencies, info, targetHeightCap) {
+    const targetHeight = targetHeightCap === null ? info.headers : Math.min(info.headers, targetHeightCap);
+    const etaSeconds = estimateEtaSeconds(dependencies.bitcoinRateTracker, info.blocks, targetHeight);
     await dependencies.progress.setPhase("bitcoin_sync", {
         blocks: info.blocks,
         headers: info.headers,
-        targetHeight: info.headers,
+        targetHeight,
         etaSeconds,
         lastError: null,
         message: dependencies.node.expectedChain === "main"
@@ -171,8 +172,11 @@ export async function syncToTip(dependencies) {
         while (true) {
             throwIfAborted(dependencies.abortSignal);
             const startInfo = await runRpc(() => dependencies.rpc.getBlockchainInfo());
-            await setBitcoinSyncProgress(dependencies, startInfo);
-            const pass = await syncAgainstBestHeight(dependencies, startInfo.blocks, runRpc);
+            const cappedBestHeight = dependencies.targetHeightCap === null || dependencies.targetHeightCap === undefined
+                ? startInfo.blocks
+                : Math.min(startInfo.blocks, dependencies.targetHeightCap);
+            await setBitcoinSyncProgress(dependencies, startInfo, dependencies.targetHeightCap ?? null);
+            const pass = await syncAgainstBestHeight(dependencies, cappedBestHeight, runRpc);
             aggregate.appliedBlocks += pass.appliedBlocks;
             aggregate.rewoundBlocks += pass.rewoundBlocks;
             if (pass.commonAncestorHeight !== null) {
@@ -182,18 +186,22 @@ export async function syncToTip(dependencies) {
             }
             const finalTip = await dependencies.client.getTip();
             const endInfo = await runRpc(() => dependencies.rpc.getBlockchainInfo());
-            const caughtUpCogcoin = endInfo.blocks < dependencies.startHeight || finalTip?.height === endInfo.blocks;
+            const endBestHeight = dependencies.targetHeightCap === null || dependencies.targetHeightCap === undefined
+                ? endInfo.blocks
+                : Math.min(endInfo.blocks, dependencies.targetHeightCap);
+            const caughtUpCogcoin = endBestHeight < dependencies.startHeight || finalTip?.height === endBestHeight;
             aggregate.endingHeight = finalTip?.height ?? null;
-            aggregate.bestHeight = endInfo.blocks;
+            aggregate.bestHeight = endBestHeight;
             aggregate.bestHashHex = endInfo.bestblockhash;
-            if (endInfo.blocks === endInfo.headers && caughtUpCogcoin) {
+            if ((dependencies.targetHeightCap !== null && dependencies.targetHeightCap !== undefined && caughtUpCogcoin)
+                || (endInfo.blocks === endInfo.headers && caughtUpCogcoin)) {
                 if (dependencies.isFollowing()) {
                     dependencies.progress.replaceFollowBlockTimes(await runRpc(() => dependencies.loadVisibleFollowBlockTimes(finalTip)));
                 }
                 await dependencies.progress.setPhase(dependencies.isFollowing() ? "follow_tip" : "complete", {
                     blocks: endInfo.blocks,
                     headers: endInfo.headers,
-                    targetHeight: endInfo.headers,
+                    targetHeight: dependencies.targetHeightCap ?? endInfo.headers,
                     lastError: null,
                     message: dependencies.isFollowing()
                         ? "Following the live Bitcoin tip."
@@ -201,8 +209,8 @@ export async function syncToTip(dependencies) {
                 });
                 return aggregate;
             }
-            await setBitcoinSyncProgress(dependencies, endInfo);
-            if (endInfo.blocks >= dependencies.startHeight && finalTip?.height !== endInfo.blocks) {
+            await setBitcoinSyncProgress(dependencies, endInfo, dependencies.targetHeightCap ?? null);
+            if (endBestHeight >= dependencies.startHeight && finalTip?.height !== endBestHeight) {
                 continue;
             }
             await sleep(DEFAULT_SYNC_CATCH_UP_POLL_MS, dependencies.abortSignal);

package/dist/bitcoind/errors.js

@@ -6,22 +6,22 @@ function appendNextStep(message, nextStep) {
 }
 export function formatManagedSyncErrorMessage(message) {
     if (message.startsWith("managed_getblock_archive_manifest_http_")) {
-        return appendNextStep(`Getblock archive manifest request failed (${message.replace("managed_getblock_archive_manifest_http_", "HTTP ")}).`, "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
+        return appendNextStep(`Getblock range manifest request failed (${message.replace("managed_getblock_archive_manifest_http_", "HTTP ")}).`, "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
     }
     if (message.startsWith("managed_getblock_archive_http_")) {
-        return appendNextStep(`Getblock archive request failed (${message.replace("managed_getblock_archive_http_", "HTTP ")}).`, "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
+        return appendNextStep(`Getblock range request failed (${message.replace("managed_getblock_archive_http_", "HTTP ")}).`, "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
     }
     if (message === "managed_getblock_archive_response_body_missing") {
-        return appendNextStep("Getblock archive server returned an empty response body.", "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
+        return appendNextStep("Getblock range server returned an empty response body.", "Wait a moment, confirm the snapshot host is reachable, then rerun sync.");
     }
     if (message === "managed_getblock_archive_resume_requires_partial_content") {
-        return appendNextStep("Getblock archive server ignored the resume request for a partial download.", "Wait a moment and rerun sync. If this keeps happening, confirm the snapshot host supports HTTP range requests.");
+        return appendNextStep("Getblock range server ignored the resume request for a partial download.", "Wait a moment and rerun sync. If this keeps happening, confirm the snapshot host supports HTTP range requests.");
     }
     if (message.startsWith("managed_getblock_archive_chunk_sha256_mismatch_")) {
-        return appendNextStep("A downloaded getblock archive chunk was corrupted and was rolled back to the last verified checkpoint.", "Wait a moment and rerun sync. If this keeps happening, check local disk health and the stability of the archive download.");
+        return appendNextStep("A downloaded getblock range chunk was corrupted and was rolled back to the last verified checkpoint.", "Wait a moment and rerun sync. If this keeps happening, check local disk health and the stability of the archive download.");
     }
     if (message === "managed_getblock_archive_sha256_mismatch" || message === "managed_getblock_archive_truncated") {
-        return appendNextStep("The downloaded getblock archive did not match the published manifest.", "Rerun sync so the archive can be downloaded again. If this keeps happening, check local disk health and the snapshot host.");
+        return appendNextStep("The downloaded getblock range did not match the published manifest.", "Rerun sync so the archive can be downloaded again. If this keeps happening, check local disk health and the snapshot host.");
     }
     if (message === "bitcoind_no_peers_for_header_sync_check_internet_or_firewall") {
         return appendNextStep("No Bitcoin peers were available for header sync.", "Check your internet access and firewall rules for outbound Bitcoin connections, then rerun sync.");

package/dist/bitcoind/progress/formatting.js

@@ -2,9 +2,9 @@ import { FIELD_LEFT, FIELD_WIDTH, PREPARING_SYNC_LINE, PROGRESS_TICK_MS, SCROLL_
 export function createDefaultMessage(phase) {
     switch (phase) {
         case "getblock_archive_download":
-            return "Downloading getblock archive.";
+            return "Downloading getblock range.";
         case "getblock_archive_import":
-            return "Bitcoin Core is importing getblock archive blocks.";
+            return "Bitcoin Core is importing getblock range blocks.";
         case "snapshot_download":
             return "Downloading UTXO snapshot.";
         case "wait_headers_for_snapshot":
@@ -126,9 +126,9 @@ function animateStatusEllipsis(now) {
 export function resolveStatusFieldText(progress, snapshotHeight, now = 0) {
     switch (progress.phase) {
         case "getblock_archive_download":
-            return `Downloading getblock archive${animateStatusEllipsis(now)}`;
+            return `Downloading getblock range${animateStatusEllipsis(now)}`;
         case "getblock_archive_import":
-            return `Importing getblock archive${animateStatusEllipsis(now)}`;
+            return `Importing getblock range${animateStatusEllipsis(now)}`;
         case "paused":
         case "snapshot_download":
             return `Downloading snapshot to ${snapshotHeight}${animateStatusEllipsis(now)}`;

package/dist/bitcoind/testing.d.ts

@@ -4,7 +4,7 @@ export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopInde
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
 export { attachOrStartManagedBitcoindService, buildManagedServiceArgsForTesting, readManagedBitcoindServiceStatusForTesting, resolveManagedBitcoindDbcacheMiB, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, writeBitcoinConfForTesting, } from "./service.js";
-export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
+export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, deleteGetblockArchiveRangeForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareGetblockArchiveRangeForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
 export { buildBitcoindArgsForTesting, createRpcClient, launchManagedBitcoindNode, resolveDefaultBitcoindDataDirForTesting, validateNodeConfigForTesting, } from "./node.js";
 export { ManagedProgressController, TtyProgressRenderer, advanceFollowSceneStateForTesting, createFollowSceneStateForTesting, createBootstrapProgressForTesting, formatCompactFollowAgeLabelForTesting, loadBannerArtForTesting, loadScrollArtForTesting, loadTrainCarArtForTesting, loadTrainArtForTesting, loadTrainSmokeArtForTesting, formatProgressLineForTesting, formatQuoteLineForTesting, renderArtFrameForTesting, renderCompletionFrameForTesting, renderFollowFrameForTesting, renderIntroFrameForTesting, resolveCompletionMessageForTesting, resolveIntroMessageForTesting, resolveStatusFieldTextForTesting, setFollowBlockTimeForTesting, setFollowBlockTimesForTesting, syncFollowSceneStateForTesting, } from "./progress.js";
 export { WritingQuoteRotator, loadWritingQuotesForTesting, shuffleIndicesForTesting, } from "./quotes.js";

package/dist/bitcoind/testing.js

@@ -4,7 +4,7 @@ export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopInde
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";
 export { attachOrStartManagedBitcoindService, buildManagedServiceArgsForTesting, readManagedBitcoindServiceStatusForTesting, resolveManagedBitcoindDbcacheMiB, stopManagedBitcoindService, shutdownManagedBitcoindServiceForTesting, writeBitcoinConfForTesting, } from "./service.js";
-export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
+export { AssumeUtxoBootstrapController, DEFAULT_SNAPSHOT_METADATA, createBootstrapStateForTesting, deleteGetblockArchiveRangeForTesting, downloadSnapshotFileForTesting, loadBootstrapStateForTesting, prepareGetblockArchiveRangeForTesting, prepareLatestGetblockArchiveForTesting, resolveBootstrapPathsForTesting, resolveGetblockArchivePathsForTesting, resolveReadyGetblockArchiveForTesting, saveBootstrapStateForTesting, validateSnapshotFileForTesting, waitForGetblockArchiveImportForTesting, waitForHeadersForTesting, } from "./bootstrap.js";
 export { buildBitcoindArgsForTesting, createRpcClient, launchManagedBitcoindNode, resolveDefaultBitcoindDataDirForTesting, validateNodeConfigForTesting, } from "./node.js";
 export { ManagedProgressController, TtyProgressRenderer, advanceFollowSceneStateForTesting, createFollowSceneStateForTesting, createBootstrapProgressForTesting, formatCompactFollowAgeLabelForTesting, loadBannerArtForTesting, loadScrollArtForTesting, loadTrainCarArtForTesting, loadTrainArtForTesting, loadTrainSmokeArtForTesting, formatProgressLineForTesting, formatQuoteLineForTesting, renderArtFrameForTesting, renderCompletionFrameForTesting, renderFollowFrameForTesting, renderIntroFrameForTesting, resolveCompletionMessageForTesting, resolveIntroMessageForTesting, resolveStatusFieldTextForTesting, setFollowBlockTimeForTesting, setFollowBlockTimesForTesting, syncFollowSceneStateForTesting, } from "./progress.js";
 export { WritingQuoteRotator, loadWritingQuotesForTesting, shuffleIndicesForTesting, } from "./quotes.js";

package/dist/bitcoind/types.d.ts

@@ -17,28 +17,27 @@ export interface SnapshotChunkManifest {
     snapshotSha256: string;
     chunkSha256s: string[];
 }
-export interface GetblockArchiveManifestBlockRecord {
-    height: number;
-    blockHash: string;
-    previousBlockHash: string;
-    recordOffset: number;
-    recordLength: number;
-    rawBlockSizeBytes: number;
-}
-export interface GetblockArchiveManifest {
+export interface GetblockRangeManifestEntry {
     formatVersion: number;
     chain: "main";
     baseSnapshotHeight: number;
     firstBlockHeight: number;
-    endHeight: number;
-    blockCount: number;
+    lastBlockHeight: number;
     artifactFilename: string;
     artifactSizeBytes: number;
     artifactSha256: string;
     chunkSizeBytes: number;
     chunkSha256s: string[];
-    blocks: GetblockArchiveManifestBlockRecord[];
 }
+export interface GetblockRangeManifest {
+    formatVersion: number;
+    chain: "main";
+    baseSnapshotHeight: number;
+    rangeSizeBlocks: number;
+    publishedThroughHeight: number;
+    ranges: GetblockRangeManifestEntry[];
+}
+export type GetblockArchiveManifest = GetblockRangeManifestEntry;
 export interface WritingQuote {
     quote: string;
     author: string;

package/dist/cli/commands/follow.js

@@ -3,7 +3,6 @@ import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolut
 import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher } from "../signals.js";
-import { confirmGetblockArchiveRestart } from "./getblock-archive-restart.js";
 export async function runFollowCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
@@ -24,7 +23,6 @@ export async function runFollowCommand(parsed, context) {
             dataDir,
             walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
-            confirmGetblockArchiveRestart: async (options) => confirmGetblockArchiveRestart(parsed, context, options),
         });
         storeOwned = false;
         const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);

package/dist/cli/commands/sync.js

@@ -4,7 +4,6 @@ import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolut
 import { writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
-import { confirmGetblockArchiveRestart } from "./getblock-archive-restart.js";
 export async function runSyncCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
@@ -25,7 +24,6 @@ export async function runSyncCommand(parsed, context) {
             dataDir,
             walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
-            confirmGetblockArchiveRestart: async (options) => confirmGetblockArchiveRestart(parsed, context, options),
         });
         storeOwned = false;
         const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);

package/dist/cli/signals.js

@@ -19,10 +19,18 @@ export function createStopSignalWatcher(signalSource, stderr, client, forceExit)
         };
         const onFirstSignal = () => {
             closing = true;
-            writeLine(stderr, "Detaching from managed Cogcoin client...");
+            writeLine(stderr, "Detaching from managed Cogcoin client and resuming background indexer follow...");
             void client.close().then(() => {
+                if (resolved) {
+                    return;
+                }
+                writeLine(stderr, "Detached cleanly; background indexer follow resumed.");
                 settle(0);
             }, () => {
+                if (resolved) {
+                    return;
+                }
+                writeLine(stderr, "Detach failed before background indexer follow was confirmed.");
                 settle(1);
             });
         };
@@ -103,5 +111,11 @@ export async function waitForCompletionOrStop(promise, stopWatcher) {
         }
         throw outcome.error;
     }
+    if (stopWatcher.isStopping()) {
+        return {
+            kind: "stopped",
+            code: await stopWatcher.promise,
+        };
+    }
     return outcome;
 }

package/dist/wallet/tx/anchor.js

@@ -227,6 +227,9 @@ function resolveAnchorOutpointForSender(state, senderIndex) {
         vout: anchoredDomain.currentCanonicalAnchorOutpoint.vout,
     };
 }
+function isFundingSender(state, sender) {
+    return sender.scriptPubKeyHex === state.funding.scriptPubKeyHex;
+}
 async function confirmAnchor(prompter, operation) {
     prompter.writeLine(`You are anchoring "${operation.chainDomain.name}" onto dedicated index ${operation.targetIdentity.localIndex}.`);
     prompter.writeLine("Anchoring is permanent chain state. This flow uses two transactions and is not rolled back automatically.");
@@ -274,10 +277,15 @@ function resolveAnchorOperation(context, domainName, foundingMessageText, foundi
     if (senderIdentity.readOnly) {
         throw new Error("wallet_anchor_owner_read_only");
     }
-    const sourceAnchorOutpoint = senderIdentity.index === context.localState.state.fundingIndex
+    const sourceAnchorOutpoint = isFundingSender(context.localState.state, {
+        localIndex: senderIdentity.index,
+        scriptPubKeyHex: senderIdentity.scriptPubKeyHex,
+        address: senderIdentity.address,
+    })
         ? null
         : resolveAnchorOutpointForSender(context.localState.state, senderIdentity.index);
-    if (senderIdentity.index !== context.localState.state.fundingIndex && sourceAnchorOutpoint === null) {
+    if (sourceAnchorOutpoint === null
+        && senderIdentity.scriptPubKeyHex !== context.localState.state.funding.scriptPubKeyHex) {
         throw new Error("wallet_anchor_owner_identity_not_supported");
     }
     const targetIdentity = selectNextDedicatedIdentityTarget(context.localState.state);
@@ -466,6 +474,8 @@ function buildTx1Plan(options) {
             expectedReplacementAnchorScriptHex: null,
             expectedReplacementAnchorValueSats: null,
             allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+            requiredSenderOutpoint: null,
+            requiredProvisionalOutpoint: null,
             errorPrefix: "wallet_anchor_tx1",
         };
     }
@@ -494,6 +504,8 @@ function buildTx1Plan(options) {
         expectedReplacementAnchorScriptHex: options.operation.sourceSender.scriptPubKeyHex,
         expectedReplacementAnchorValueSats: BigInt(options.state.anchorValueSats),
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        requiredSenderOutpoint: options.operation.sourceAnchorOutpoint,
+        requiredProvisionalOutpoint: null,
         errorPrefix: "wallet_anchor_tx1",
     };
 }
@@ -538,19 +550,53 @@ function buildTx2Plan(options) {
         expectedReplacementAnchorScriptHex: null,
         expectedReplacementAnchorValueSats: null,
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        requiredSenderOutpoint: null,
+        requiredProvisionalOutpoint: {
+            txid: provisional.txid,
+            vout: provisional.vout,
+        },
         errorPrefix: "wallet_anchor_tx2",
     };
 }
+function getDecodedInputScriptPubKeyHex(input) {
+    return input.prevout?.scriptPubKey?.hex ?? null;
+}
+function getDecodedInputVout(input) {
+    const vout = input.vout;
+    return typeof vout === "number" ? vout : null;
+}
+function inputMatchesOutpoint(input, outpoint) {
+    return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
+}
+function assertNoUnexpectedAnchorInputs(inputs, allowedScripts, unexpectedInputErrorCode) {
+    for (const input of inputs) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+        if (scriptPubKeyHex === null || !allowedScripts.has(scriptPubKeyHex)) {
+            throw new Error(unexpectedInputErrorCode);
+        }
+    }
+}
 function validateTx1Draft(decoded, funded, plan) {
     const inputs = decoded.tx.vin;
     const outputs = decoded.tx.vout;
-    if (inputs.length === 0 || inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (inputs.length === 0) {
+        throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
+    }
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
-    for (let index = 1; index < inputs.length; index += 1) {
-        if (inputs[index]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+    if (plan.requiredSenderOutpoint !== null) {
+        if (!inputMatchesOutpoint(inputs[0], plan.requiredSenderOutpoint)) {
+            throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
+        }
+        if (inputs.length < 2 || getDecodedInputScriptPubKeyHex(inputs[1]) !== plan.allowedFundingScriptPubKeyHex) {
             throw new Error(`${plan.errorPrefix}_unexpected_funding_input`);
         }
+        assertNoUnexpectedAnchorInputs(inputs.slice(2), new Set([plan.allowedFundingScriptPubKeyHex]), `${plan.errorPrefix}_unexpected_funding_input`);
+    }
+    else {
+        assertNoUnexpectedAnchorInputs(inputs, new Set([plan.allowedFundingScriptPubKeyHex]), `${plan.errorPrefix}_unexpected_funding_input`);
     }
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
@@ -586,14 +632,18 @@ function validateTx1Draft(decoded, funded, plan) {
 function validateTx2Draft(decoded, funded, plan) {
     const inputs = decoded.tx.vin;
     const outputs = decoded.tx.vout;
-    if (inputs.length === 0 || inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (inputs.length === 0 || plan.requiredProvisionalOutpoint === null) {
         throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
     }
-    for (let index = 1; index < inputs.length; index += 1) {
-        if (inputs[index]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
-            throw new Error(`${plan.errorPrefix}_unexpected_funding_input`);
-        }
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex
+        || !inputMatchesOutpoint(inputs[0], plan.requiredProvisionalOutpoint)) {
+        throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
+    }
+    if (inputs.length < 2 || getDecodedInputScriptPubKeyHex(inputs[1]) !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error(`${plan.errorPrefix}_unexpected_funding_input`);
     }
+    assertNoUnexpectedAnchorInputs(inputs.slice(2), new Set([plan.allowedFundingScriptPubKeyHex]), `${plan.errorPrefix}_unexpected_funding_input`);
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
     }
@@ -625,6 +675,9 @@ async function buildTx1(options) {
         validateFundedDraft: validateTx1Draft,
         finalizeErrorCode: "wallet_anchor_tx1_finalize_failed",
         mempoolRejectPrefix: "wallet_anchor_tx1_mempool_rejected",
+        builderOptions: {
+            addInputs: false,
+        },
     });
 }
 async function buildTx2(options) {
@@ -636,6 +689,7 @@ async function buildTx2(options) {
         finalizeErrorCode: "wallet_anchor_tx2_finalize_failed",
         mempoolRejectPrefix: "wallet_anchor_tx2_mempool_rejected",
         builderOptions: {
+            addInputs: false,
             includeUnsafe: true,
             minConf: 0,
         },

package/package.json

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