@secondlayer/cli 22.0.1 → 22.1.0

package/dist/cli.js

@@ -29488,7 +29488,7 @@ var init_git_status = () => {};
 
 // ../../node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS(function(exports, module) {
-  var __dirname = "/Users/ryan/projects/secondlayer/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/ryan/projects/secondlayer/.claude/worktrees/rel313/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/rel313/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -202711,7 +202711,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "22.0.1",
+  version: "22.1.0",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -204184,6 +204184,126 @@ import {
   reportVerify
 } from "@secondlayer/shared/coverage";
 import { getDb as getDb3 } from "@secondlayer/shared/db";
+
+// src/lib/archive-heights.ts
+import {
+  PerHeightDigestAccumulator
+} from "@secondlayer/shared/archive/per-height-digest";
+import {
+  streamHeightDigests
+} from "@secondlayer/shared/archive/semantic-digest-builder";
+var PART_FOR_DATASET = {
+  blocks: "block",
+  transactions: "transactions",
+  events: "events"
+};
+async function localPerHeightDigests(db, fromBlock, toBlock, datasets = ["blocks", "transactions", "events"]) {
+  const accumulator = new PerHeightDigestAccumulator;
+  for await (const { height, digest } of streamHeightDigests(db, "blocks", fromBlock, toBlock)) {
+    accumulator.setBlockDigest(height, digest);
+  }
+  if (datasets.includes("transactions")) {
+    for await (const { height, digest } of streamHeightDigests(db, "transactions", fromBlock, toBlock)) {
+      accumulator.appendTransactionDigest(height, digest);
+    }
+  }
+  if (datasets.includes("events")) {
+    for await (const { height, digest } of streamHeightDigests(db, "events", fromBlock, toBlock)) {
+      accumulator.appendEventDigest(height, digest);
+    }
+  }
+  const rows = new Map;
+  for (const row of accumulator.drain(fromBlock, toBlock)) {
+    rows.set(row.height, row);
+  }
+  return rows;
+}
+function sidecarsCovering(digestIndex, fromBlock, toBlock) {
+  return (digestIndex ?? []).filter((p) => p.from_block <= toBlock && p.to_block >= fromBlock);
+}
+async function fetchSidecarRows(reference, partition) {
+  const bytes = await fetchVerifiedPartition(reference, partition);
+  const rows = [];
+  for await (const raw of readPartitionRows(bytes, `digests-${partition.from_block}-${partition.to_block}`)) {
+    const row = raw;
+    rows.push({
+      height: Number(row.height),
+      block_digest: String(row.block_digest),
+      transactions_rollup: row.transactions_rollup == null ? null : String(row.transactions_rollup),
+      events_rollup: row.events_rollup == null ? null : String(row.events_rollup)
+    });
+  }
+  return rows;
+}
+function compareHeights(params) {
+  const { dataset, fromBlock, toBlock, local, archive, covered } = params;
+  const inCoverage = (h) => covered.some((c) => h >= c.from_block && h <= c.to_block);
+  const heights = new Set;
+  for (const h of archive.keys())
+    heights.add(h);
+  for (const h of local.keys())
+    if (inCoverage(h))
+      heights.add(h);
+  const out = [];
+  for (const height of [...heights].sort((a, b) => a - b)) {
+    if (height < fromBlock || height > toBlock)
+      continue;
+    const mine = local.get(height);
+    const theirs = archive.get(height);
+    if (!mine && theirs) {
+      out.push({ height, parts: ["missing-local"] });
+    } else if (mine && !theirs) {
+      out.push({ height, parts: ["missing-archive"] });
+    } else if (mine && theirs && !partsMatch(dataset, mine, theirs)) {
+      out.push({ height, parts: [PART_FOR_DATASET[dataset]] });
+    }
+  }
+  return out;
+}
+function partsMatch(dataset, a, b) {
+  if (dataset === "blocks")
+    return a.block_digest === b.block_digest;
+  if (dataset === "transactions") {
+    return a.transactions_rollup === b.transactions_rollup;
+  }
+  return a.events_rollup === b.events_rollup;
+}
+async function divergentHeightsForRange(params) {
+  const { db, reference, dataset, fromBlock, toBlock } = params;
+  const sidecars = sidecarsCovering(params.digestIndex, fromBlock, toBlock);
+  if (sidecars.length === 0)
+    return null;
+  const archive = new Map;
+  for (const sidecar of sidecars) {
+    for (const row of await fetchSidecarRows(reference, sidecar)) {
+      archive.set(row.height, row);
+    }
+  }
+  const local = await localPerHeightDigests(db, fromBlock, toBlock, [dataset]);
+  return compareHeights({
+    dataset,
+    fromBlock,
+    toBlock,
+    local,
+    archive,
+    covered: sidecars
+  });
+}
+function mergeRepairRanges(ranges) {
+  const sorted = [...ranges].sort((a, b) => a.from_block - b.from_block || a.to_block - b.to_block);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && range.from_block <= last.to_block + 1) {
+      last.to_block = Math.max(last.to_block, range.to_block);
+    } else {
+      merged.push({ from_block: range.from_block, to_block: range.to_block });
+    }
+  }
+  return merged;
+}
+
+// src/commands/verify.ts
 init_output();
 init_resolve_auth();
 
@@ -204578,6 +204698,7 @@ function parseHeight3(value, flag) {
   }
   return parsed;
 }
+var MAX_HEIGHTS_SHOWN = 20;
 function statusLabel(status) {
   if (status === "match")
     return green("ok");
@@ -204616,9 +204737,10 @@ Exit codes:
         envPem: process.env.ARCHIVE_SIGNING_PUBLIC_KEY ?? process.env.STREAMS_SIGNING_PUBLIC_KEY,
         allowHostedApi: !isOssMode()
       });
-      const { manifest, origin } = await loadReference(opts.against, {
+      const loaded = await loadReference(opts.against, {
         publicKeyPem: publicKey
       });
+      const { manifest, origin } = loaded;
       const signature = checkSignature(manifest, publicKey, !!opts.insecure);
       if (!signature.verified && !opts.insecure) {
         printError(`Cannot trust the reference: ${signature.reason}.`, {
@@ -204751,6 +204873,30 @@ Exit codes:
         }))
       ];
       const diverged = all.filter((c) => c.status !== "match");
+      const digestIndex = manifest.digest_index;
+      const heightNotes = [];
+      if (diverged.length > 0 && !digestIndex?.length) {
+        heightNotes.push("This snapshot has no per-height digests; exact diverging heights need a newer snapshot.");
+      } else {
+        for (const range of diverged) {
+          try {
+            const heights = await divergentHeightsForRange({
+              db,
+              reference: loaded,
+              digestIndex,
+              dataset: range.dataset,
+              fromBlock: range.from_block,
+              toBlock: range.to_block
+            });
+            if (heights)
+              range.divergent_heights = heights;
+            else
+              heightNotes.push(`No per-height digests cover ${range.from_block}-${range.to_block}.`);
+          } catch (err) {
+            heightNotes.push(`Could not narrow ${range.from_block}-${range.to_block} to heights: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      }
       const verdict = reportVerify({
         target,
         mode,
@@ -204763,7 +204909,8 @@ Exit codes:
         signature_verified: signature.verified,
         ranges_checked: all.length,
         semantic_checks: semanticChecks.length,
-        divergent_ranges: diverged
+        divergent_ranges: diverged,
+        ...heightNotes.length > 0 ? { note: heightNotes.join(" ") } : {}
       };
       output({
         json: opts.json,
@@ -204783,11 +204930,28 @@ Exit codes:
             String(d.expected_rows),
             String(d.actual_rows)
           ])));
+          for (const range of diverged) {
+            const heights = range.divergent_heights;
+            if (!heights)
+              continue;
+            console.error("");
+            console.error(`${range.from_block}-${range.to_block} ${range.dataset}: ${heights.length} diverging height${heights.length === 1 ? "" : "s"}`);
+            for (const h of heights.slice(0, MAX_HEIGHTS_SHOWN)) {
+              console.error(`  ${h.height}  ${h.parts.join(", ")}`);
+            }
+            if (heights.length > MAX_HEIGHTS_SHOWN) {
+              console.error(dim(`  and ${heights.length - MAX_HEIGHTS_SHOWN} more (see --json)`));
+            }
+          }
+          if (heightNotes.length > 0) {
+            console.error("");
+            for (const line of heightNotes)
+              console.error(dim(`  ${line}`));
+          }
           console.error("");
           console.error(dim("These ranges hold different data than the signed archive. Repair with:"));
-          const first = diverged[0];
-          if (first) {
-            console.error(dim(`  secondlayer repair --from-block ${first.from_block} --to-block ${first.to_block}`));
+          for (const range of mergeRepairRanges(diverged)) {
+            console.error(dim(`  secondlayer repair --from-block ${range.from_block} --to-block ${range.to_block}`));
           }
         }
       });
@@ -208690,5 +208854,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=77FBD5CCBD0906B064756E2164756E21
+//# debugId=32F86A2D9F7E084964756E2164756E21
 //# sourceMappingURL=cli.js.map