@secondlayer/cli 18.0.0 → 19.0.0

package/dist/cli.js

@@ -202495,7 +202495,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "18.0.0",
+  version: "19.0.0",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -202535,7 +202535,7 @@ var package_default = {
     "@secondlayer/bundler": "^0.6.1",
     "@secondlayer/scaffold": "^1.6.1",
     "@secondlayer/sdk": "^13.0.0",
-    "@secondlayer/shared": "^11.14.0",
+    "@secondlayer/shared": "^11.15.1",
     "@secondlayer/stacks": "^6.1.0",
     "@secondlayer/subgraphs": "^6.2.5",
     esbuild: "^0.28.2",
@@ -203516,6 +203516,193 @@ async function reverify(db, reference, ranges) {
   }
   return remaining;
 }
+function findChildPartition(partitions, dataset, fromBlock, toBlock) {
+  return partitions.find((p) => p.dataset === dataset && p.from_block === fromBlock && p.to_block === toBlock);
+}
+function expectedZeroRows(zeroRecordRanges, dataset, fromBlock, toBlock) {
+  return zeroRecordRanges.some((r) => r.dataset === dataset && r.from_block === fromBlock && r.to_block === toBlock);
+}
+async function planChildPartitionDivergence(db, partitions, zeroRecordRanges, inRange) {
+  const ranges = new Map;
+  for (const p of partitions) {
+    if (p.dataset !== "transactions" && p.dataset !== "events")
+      continue;
+    if (!inRange(p.from_block, p.to_block))
+      continue;
+    ranges.set(`${p.from_block}-${p.to_block}`, {
+      from: p.from_block,
+      to: p.to_block
+    });
+  }
+  const mismatches = [];
+  for (const { from, to } of ranges.values()) {
+    const txPartition = findChildPartition(partitions, "transactions", from, to);
+    const evPartition = findChildPartition(partitions, "events", from, to);
+    const expectedTx = txPartition?.row_count ?? (expectedZeroRows(zeroRecordRanges, "transactions", from, to) ? 0 : null);
+    const expectedEv = evPartition?.row_count ?? (expectedZeroRows(zeroRecordRanges, "events", from, to) ? 0 : null);
+    if (expectedTx === null && expectedEv === null)
+      continue;
+    const actualTx = (await computeRangeDigest2(db, "transactions", from, to)).row_count;
+    const actualEv = (await computeRangeDigest2(db, "events", from, to)).row_count;
+    if (expectedTx !== null && actualTx !== expectedTx || expectedEv !== null && actualEv !== expectedEv) {
+      mismatches.push({
+        from_block: from,
+        to_block: to,
+        transactions: { expected: expectedTx ?? actualTx, actual: actualTx },
+        events: { expected: expectedEv ?? actualEv, actual: actualEv }
+      });
+    }
+  }
+  return mismatches;
+}
+async function applyChildRangeFix(rawClient, reference, mismatch, gate) {
+  const partitions = reference.manifest.partitions ?? [];
+  const txPartition = findChildPartition(partitions, "transactions", mismatch.from_block, mismatch.to_block);
+  const evPartition = findChildPartition(partitions, "events", mismatch.from_block, mismatch.to_block);
+  const txBytes = txPartition ? await fetchVerifiedPartition(reference, txPartition, gate) : null;
+  const evBytes = evPartition ? await fetchVerifiedPartition(reference, evPartition, gate) : null;
+  const written = { transactions: 0, events: 0 };
+  await rawClient.begin(async (tx) => {
+    await tx.unsafe("DELETE FROM events WHERE block_height BETWEEN $1 AND $2", [
+      mismatch.from_block,
+      mismatch.to_block
+    ]);
+    await tx.unsafe("DELETE FROM transactions WHERE block_height BETWEEN $1 AND $2", [mismatch.from_block, mismatch.to_block]);
+    if (txBytes) {
+      const writable = await tx.unsafe(copyStatement2("transactions")).writable();
+      written.transactions = await writeRowsToCopyStream2({
+        writable,
+        dataset: "transactions",
+        rows: readPartitionRows(txBytes, `repair-transactions-${mismatch.from_block}`)
+      });
+    }
+    if (evBytes) {
+      const writable = await tx.unsafe(copyStatement2("events")).writable();
+      written.events = await writeRowsToCopyStream2({
+        writable,
+        dataset: "events",
+        rows: readPartitionRows(evBytes, `repair-events-${mismatch.from_block}`)
+      });
+    }
+  });
+  return written;
+}
+async function runChildOnlyRepair(params) {
+  const { reference, childMismatches, apply, json, yes } = params;
+  if (childMismatches.length === 0) {
+    success("Nothing to repair — local data matches the archive.");
+    output({ json, data: { status: "clean", fixes: [] }, human: () => {} });
+    process.exit(REPAIR_EXIT.OK);
+  }
+  const partitions = reference.manifest.partitions ?? [];
+  const fetchPaths = childMismatches.flatMap((m) => {
+    const tx = findChildPartition(partitions, "transactions", m.from_block, m.to_block);
+    const ev = findChildPartition(partitions, "events", m.from_block, m.to_block);
+    return [tx?.path, ev?.path].filter((p) => p !== undefined);
+  });
+  let gate;
+  let quoteLine;
+  if (apply && isOfficialArchive(reference)) {
+    const result = await quoteArchiveFetch(fetchPaths, "repair");
+    if (!result.ok) {
+      printError(result.kind === "not_configured" ? ARCHIVE_GATE_NOT_CONFIGURED_MESSAGE : result.message);
+      process.exit(REPAIR_EXIT.UNANCHORED);
+    }
+    if (!result.quote.sufficient) {
+      printError(formatInsufficientMessage(result.quote));
+      process.exit(REPAIR_EXIT.UNANCHORED);
+    }
+    quoteLine = formatQuoteValue(result.quote, "repair");
+    note(`  metered: ${quoteLine}`);
+    if (shouldPromptForGatedFetch({ yes })) {
+      if (json) {
+        writeData(JSON.stringify(confirmationRequiredPayload(result.quote)));
+        process.exit(REPAIR_EXIT.UNANCHORED);
+      }
+      const proceed = await confirmDestructive({
+        message: `Fetch ${fetchPaths.length} partition(s) from the archive?`,
+        yes
+      });
+      if (!proceed) {
+        note("Nothing was fetched.");
+        process.exit(REPAIR_EXIT.UNANCHORED);
+      }
+    }
+    gate = createGatedFetcher(fetchPaths, "repair");
+  }
+  const applied = { transactions: 0, events: 0 };
+  if (apply) {
+    const rawClient = getRawClient2("source");
+    for (const mismatch of childMismatches) {
+      const result = await applyChildRangeFix(rawClient, reference, mismatch, gate);
+      applied.transactions += result.transactions;
+      applied.events += result.events;
+    }
+  }
+  const db = getDb2();
+  let remaining = childMismatches.length;
+  if (apply) {
+    remaining = 0;
+    for (const mismatch of childMismatches) {
+      const [actualTx, actualEv] = await Promise.all([
+        computeRangeDigest2(db, "transactions", mismatch.from_block, mismatch.to_block),
+        computeRangeDigest2(db, "events", mismatch.from_block, mismatch.to_block)
+      ]);
+      if (actualTx.row_count !== mismatch.transactions.expected || actualEv.row_count !== mismatch.events.expected) {
+        remaining++;
+      }
+    }
+  }
+  const complete = apply && remaining === 0;
+  const report = {
+    status: apply ? complete ? "repaired" : "incomplete" : "plan",
+    reference: reference.origin,
+    divergent_ranges: 0,
+    blocks_to_replace: 0,
+    blocks_to_insert: 0,
+    local_only_heights: [],
+    applied: 0,
+    rows_written: { blocks: 0, ...applied },
+    datasets_rewritten: apply ? ["transactions", "events"] : [],
+    heights_missing_child_partitions: [],
+    child_partition_mismatches: childMismatches,
+    fixes: [],
+    metered: quoteLine ?? null
+  };
+  output({
+    json,
+    data: report,
+    human: () => {
+      if (apply) {
+        const written = `${applied.transactions} transactions, ${applied.events} events`;
+        if (complete) {
+          success(`Repaired ${childMismatches.length} range(s) (rewrote ${written}); blocks were already correct.`);
+        } else {
+          warn(`Rewrote ${written} but ${remaining} range(s) still diverge from the archive.`);
+        }
+      } else {
+        warn(`${childMismatches.length} range(s) have transactions/events that diverge from the archive, while their blocks match.`);
+        console.error("");
+        console.error(formatTable([
+          "RANGE",
+          "TX EXPECTED",
+          "TX LOCAL",
+          "EVENTS EXPECTED",
+          "EVENTS LOCAL"
+        ], childMismatches.slice(0, 20).map((m) => [
+          `${m.from_block}-${m.to_block}`,
+          String(m.transactions.expected),
+          String(m.transactions.actual),
+          String(m.events.expected),
+          String(m.events.actual)
+        ])));
+        console.error("");
+        console.error(dim("(dry-run — pass --apply to write the repair)"));
+      }
+    }
+  });
+  process.exit(complete ? REPAIR_EXIT.OK : REPAIR_EXIT.DIVERGENCE_REMAINS);
+}
 function attachRepairCommand(cmd) {
   return cmd.requiredOption("--against <manifest>", "archive manifest: an https URL or a local file path").option("--from-block <n>", "first height to consider").option("--to-block <n>", "last height to consider").option("--apply", "write the repair (default is a dry-run plan)").option("--public-key <pem>", "pin a signing key; default is the archive key built into this release").option("-y, --yes", "skip the confirmation prompt for a metered fetch").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
@@ -203528,6 +203715,11 @@ archive's partitions for that height. When the reference carries no
 transactions or events partition for a height, the block is rewritten alone,
 the run names the height, and it exits 1.
 
+When blocks already match the archive but a transactions or events partition
+does not, that range's transactions and events are replaced outright — there
+is no block or fork boundary to preserve, only stale rows underneath one that
+was never wrong.
+
 Exit codes:
   0  nothing to repair, or the repair completed and re-verified clean
   1  divergence remains (dry-run, or repair did not fully resolve it)
@@ -203565,13 +203757,15 @@ Exit codes:
       }
       const divergent = compareRangeDigests(local, referenceDigests).filter((c) => c.status !== "match");
       if (divergent.length === 0) {
-        success("Nothing to repair — local blocks match the archive.");
-        output({
-          json: opts.json,
-          data: { status: "clean", fixes: [] },
-          human: () => {}
+        const childMismatches = await planChildPartitionDivergence(db, reference.manifest.partitions ?? [], reference.manifest.zero_record_ranges ?? [], inRange);
+        await runChildOnlyRepair({
+          reference,
+          childMismatches,
+          apply: !!opts.apply,
+          json: !!opts.json,
+          yes: !!opts.yes
         });
-        process.exit(REPAIR_EXIT.OK);
+        return;
       }
       const partitions = (reference.manifest.partitions ?? []).filter((p) => p.dataset === "blocks" && divergent.some((d) => d.from_block === p.from_block && d.to_block === p.to_block));
       const childPartitions = opts.apply ? (reference.manifest.partitions ?? []).filter((p) => (p.dataset === "transactions" || p.dataset === "events") && divergent.some((d) => p.from_block <= d.to_block && p.to_block >= d.from_block)) : [];
@@ -203672,7 +203866,7 @@ Exit codes:
           warn(`  the reference has no ${dataset} partition for ${heights.length} height(s): ${heights.slice(0, 5).join(", ")}${heights.length > 5 ? ", …" : ""}`);
         }
         for (const height of missingHeights.slice(0, 5)) {
-          console.error(dim(`  transactions/events at ${height}: run \`secondlayer bootstrap --from-block ${height} --to-block ${height}\``));
+          console.error(dim(`  the archive has no transactions/events at ${height} either: it cannot be repaired in place; re-ingest ${height} from your own node, or bootstrap a fresh database from the archive`));
         }
       }
       output({
@@ -209059,5 +209253,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=268D1F88F7CF1FDE64756E2164756E21
+//# debugId=840D684799E83C9864756E2164756E21
 //# sourceMappingURL=cli.js.map