@mikeargento/bitgraph-audit 0.9.0 → 0.10.0

package/src/floors.ts

@@ -0,0 +1,242 @@
+// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
+
+/**
+ * bitgraph-audit signed floors (enclave v10)
+ *
+ * From enclave v10 a proof's floor is a Base block the enclave signs into the
+ * proof as commit.slotFloor { chain: "base", evmChainId: 8453, blockNumber,
+ * blockHash, blockTimestamp }, one per proof, instead of an Ethereum anchor
+ * (commit.slotAnchor, read through the anchor proofs of the chain). Every
+ * floor is read through signedFloorOf from bitgraph-verify, which refuses a
+ * proof that signs both kinds: such a proof is ambiguous and nothing is read
+ * from it as a floor.
+ *
+ * What a Base floor gives the temporal stage: a NOT-BEFORE for the proof that
+ * signs it, grounded in block-hash unpredictability (the block hash did not
+ * exist before the block, and the proof signs it). Never a not-after: a later
+ * proof's floor block can predate this proof, so a floor bounds nothing
+ * before it.
+ *
+ * The block time. Base mainnet stamps every block by its height, and the
+ * enclave signs the time it read from a header it hashed itself. When the
+ * bundle carries that header (a floor header file, bitgraph-floor-header/1,
+ * as the carrier/3 unpacker writes it; or the floor inside a ceiling file or
+ * an export) it is checked with checkFloorHeader: keccak-256 to the signed
+ * hash, the signed number and time, Base mainnet's schedule. Without one the
+ * time is the signed one, which must still be on Base mainnet's schedule for
+ * the signed number, and confirming the block itself needs a Base lookup,
+ * which this offline audit never makes.
+ *
+ * A floor stamped after the proof's own attestation document is withheld as a
+ * bound (floorTimeIsBound): the record did not exist before that block, but
+ * the block's time cannot be a "not before" for a record already attested.
+ *
+ * Proofs with no slotFloor are not read here at all: bundles from before the
+ * cutover audit exactly as before.
+ */
+
+import {
+  baseHeaderFields,
+  checkFloorHeader,
+  evmHexToBytes,
+  floorTimeIsBound,
+  onBaseSchedule,
+  signedFloorOf,
+} from "@mikeargento/bitgraph-verify";
+import type { SignedFloor } from "@mikeargento/bitgraph-verify";
+import { attestationTimestampMs } from "./attestation.js";
+import type { FloorProblem, IngestResult, ObservedProof, SignedFloorRecord } from "./types.js";
+
+/** A Base floor that bounds the proof signing it. */
+export interface FloorEvidence {
+  /** The proof that signs the floor. */
+  proofHash: string;
+  blockNumber: number;
+  blockHash: string;
+  /** Unix seconds: the signed time, equal to the checked header's when one was carried. */
+  timestamp: number;
+  timeSource: "header" | "signed";
+}
+
+export interface FloorReading {
+  /** Base floors usable as not-before bounds, keyed by the proof that signs them. */
+  bounds: Map<string, FloorEvidence>;
+  /** Every Base floor a proof signs, bounding or withheld, in observation order. */
+  records: SignedFloorRecord[];
+  problems: FloorProblem[];
+}
+
+interface HeaderCandidate {
+  path: string;
+  raw: Uint8Array;
+  /** Only floor header files are judged here; ceilings and exports are judged by their own stages. */
+  fromFloorFile: boolean;
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+function iso(unix: number): string {
+  return new Date(unix * 1000).toISOString();
+}
+
+function firstPath(p: ObservedProof): string | undefined {
+  return p.sources[0]?.path;
+}
+
+/** Read every Base floor the bundle's proofs sign, and the headers that check them. */
+export function readSignedFloors(ingest: IngestResult): FloorReading {
+  const problems: FloorProblem[] = [];
+  const records: SignedFloorRecord[] = [];
+  const bounds = new Map<string, FloorEvidence>();
+
+  // The Base floors the proofs sign, by block hash (to match header files).
+  const signedHashes = new Set<string>();
+  for (const p of ingest.proofs) {
+    const f = p.proof.commit?.slotFloor as { blockHash?: unknown } | undefined;
+    if (f !== undefined && typeof f.blockHash === "string") signedHashes.add(f.blockHash.toLowerCase());
+  }
+
+  // Headers in the bundle, by the hash their bytes compute to.
+  const headers = new Map<string, HeaderCandidate[]>();
+  const add = (hash: string, c: HeaderCandidate): void => {
+    const list = headers.get(hash) ?? [];
+    list.push(c);
+    headers.set(hash, list);
+  };
+  for (const file of ingest.floorHeaders ?? []) {
+    const json = file.json;
+    const header = json["header"];
+    const fields = typeof header === "string" ? baseHeaderFields(header) : null;
+    if (json["chain"] !== "base" || fields === null) {
+      problems.push({
+        code: "floor-header-malformed",
+        path: file.path,
+        message:
+          json["chain"] !== "base"
+            ? `the floor header file names chain ${JSON.stringify(json["chain"])}; only a Base header (chain "base") is a floor header`
+            : "the floor header file carries no readable Base block header",
+      });
+      continue;
+    }
+    const declared = typeof json["blockHash"] === "string" ? (json["blockHash"] as string).toLowerCase() : undefined;
+    if (declared !== undefined && declared !== fields.blockHash) {
+      problems.push({
+        code: "floor-header-mismatch",
+        path: file.path,
+        message: `the header in this file hashes to ${fields.blockHash}, not to the block it names (${declared})`,
+      });
+      continue;
+    }
+    if (!signedHashes.has(fields.blockHash)) {
+      problems.push({
+        code: "floor-header-unmatched",
+        path: file.path,
+        message: `the header is Base block ${fields.blockNumber} (${fields.blockHash}), which no proof in this bundle signs as its floor`,
+      });
+      continue;
+    }
+    add(fields.blockHash, { path: file.path, raw: evmHexToBytes(header as string), fromFloorFile: true });
+  }
+  // The floor a ceiling file or an export carries, when it is a Base header.
+  const carried = (path: string, floor: Record<string, unknown> | null, field: string): void => {
+    if (floor === null || floor["chain"] !== "base" || typeof floor[field] !== "string") return;
+    const fields = baseHeaderFields(floor[field] as string);
+    if (fields === null || !signedHashes.has(fields.blockHash)) return;
+    add(fields.blockHash, { path, raw: evmHexToBytes(floor[field] as string), fromFloorFile: false });
+  };
+  for (const c of ingest.ceilings ?? []) carried(c.path, record(c.json["floor"]), "blockHeader");
+  for (const e of ingest.exports ?? []) if (e.status === "ok") carried(e.path, record(e.json["floor"]), "header");
+
+  for (const p of ingest.proofs) {
+    const commit = p.proof.commit as unknown as Record<string, unknown> | undefined;
+    if (commit === undefined || commit["slotFloor"] === undefined) continue;
+    const path = firstPath(p);
+    let floor: SignedFloor | null;
+    try {
+      floor = signedFloorOf(p.proof);
+    } catch (e) {
+      const both = commit["slotAnchor"] !== undefined;
+      problems.push({
+        code: both ? "floor-ambiguous" : "floor-malformed",
+        proofHash: p.proofHash,
+        ...(path !== undefined ? { path } : {}),
+        message: both
+          ? "the proof signs two floors (commit.slotAnchor, an Ethereum anchor, and commit.slotFloor, a Base block); it is ambiguous and neither is read as its floor"
+          : `the proof's commit.slotFloor is not a Base floor: ${(e as Error).message}`,
+      });
+      continue;
+    }
+    if (floor === null || floor.chain !== "base" || floor.blockTimestamp === undefined) continue;
+    const base = {
+      proofHash: p.proofHash,
+      chain: "base" as const,
+      blockNumber: floor.blockNumber,
+      blockHash: floor.blockHash,
+      blockTimestamp: floor.blockTimestamp,
+    };
+    const withheld = (reason: string, header: SignedFloorRecord["header"], headerPath?: string): void => {
+      records.push({ ...base, header, ...(headerPath !== undefined ? { headerPath } : {}), bound: "withheld", withheldReason: reason });
+    };
+
+    if (!onBaseSchedule(floor.blockNumber, floor.blockTimestamp)) {
+      const reason = `the signed time of Base block ${floor.blockNumber} (${floor.blockTimestamp}) is not Base mainnet's schedule for that block`;
+      problems.push({ code: "floor-off-schedule", proofHash: p.proofHash, ...(path !== undefined ? { path } : {}), message: reason });
+      withheld(reason, "not-carried");
+      continue;
+    }
+
+    // A header in the bundle for the signed block: every floor header file
+    // naming it must hold; the first that holds dates the floor.
+    let checkedPath: string | undefined;
+    let mismatch: string | undefined;
+    for (const c of headers.get(floor.blockHash) ?? []) {
+      const r = checkFloorHeader(floor, c.raw, "base");
+      if (r.ok) {
+        checkedPath ??= c.path;
+      } else if (c.fromFloorFile) {
+        mismatch = `${c.path}: ${r.reason}`;
+        problems.push({
+          code: "floor-header-mismatch",
+          proofHash: p.proofHash,
+          path: c.path,
+          message: `the floor header does not match the Base floor the proof signs: ${r.reason}`,
+        });
+      }
+    }
+    const header: SignedFloorRecord["header"] = checkedPath !== undefined ? "checked" : "not-carried";
+    if (mismatch !== undefined) {
+      withheld(`a floor header in the bundle contradicts the signed floor (${mismatch})`, header, checkedPath);
+      continue;
+    }
+    if (p.verification?.status === "failed") {
+      withheld("the proof does not verify, so the floor in it is not a signed one", header, checkedPath);
+      continue;
+    }
+    const attestedMs = attestationTimestampMs(
+      ((p.proof as { environment?: { attestation?: { reportB64?: string } } }).environment?.attestation?.reportB64) ?? ""
+    );
+    const timeOk = floorTimeIsBound(floor.blockTimestamp, attestedMs);
+    if (!timeOk.ok) {
+      withheld(timeOk.reason, header, checkedPath);
+      continue;
+    }
+    records.push({ ...base, header, ...(checkedPath !== undefined ? { headerPath: checkedPath } : {}), bound: "not-before" });
+    bounds.set(p.proofHash, {
+      proofHash: p.proofHash,
+      blockNumber: floor.blockNumber,
+      blockHash: floor.blockHash,
+      timestamp: floor.blockTimestamp,
+      timeSource: checkedPath !== undefined ? "header" : "signed",
+    });
+  }
+  return { bounds, records, problems };
+}
+
+/** The sentence a Base floor bound states about its block time, shared by the reports. */
+export function baseFloorTimeSentence(blockNumber: number | string, timestamp: number, timeSource: "header" | "signed"): string {
+  return timeSource === "header"
+    ? `Base block ${blockNumber} is stamped ${iso(timestamp)}; its header is in the bundle and was checked against the signed block hash, number and time.`
+    : `Base block ${blockNumber} is stamped ${iso(timestamp)} as the proof signs it, on Base mainnet's schedule for that block; no header for it is in the bundle, so confirming the block needs a Base lookup.`;
+}

package/src/index.ts

@@ -65,6 +65,10 @@ export type {
   TemporalSegment,
   AnchorOrderedPair,
   TemporalAnalysis,
+  SignedFloorRecord,
+  FloorProblem,
+  FloorProblemCode,
+  FloorHeaderFile,
   AttestationCheck,
   NitroValidationOptions,
   NitroValidationResult,
@@ -109,6 +113,10 @@ export { identifyAnchors } from "./anchors.js";
 export { verifyAnchorWitnesses, verifyAnchorWitness } from "./witness.js";
 
 export { deriveTemporalBounds } from "./temporal.js";
+// Base floors (enclave v10): the floor each proof signs, read through signedFloorOf.
+export { readSignedFloors } from "./floors.js";
+export type { FloorEvidence, FloorReading } from "./floors.js";
+export { FLOOR_HEADER_VERSION } from "./ingest.js";
 export { verifyCeilings, BITGRAPH_CEILING_WRITER, BASE_MAINNET_CHAIN_ID } from "./ceilings.js";
 export type { CeilingAuditOptions } from "./ceilings.js";
 

package/src/ingest.ts

@@ -20,6 +20,10 @@
  * exactly like a proof file. A file that declares another bitgraph-export
  * format, or lacks an export's structure, is listed as rejected.
  *
+ * A floor header file (bitgraph-floor-header/1, found by its version field)
+ * is evidence too: the header of the Base block a proof signs as its floor
+ * (commit.slotFloor, enclave v10), listed for the temporal stage.
+ *
  * Memory: archives are never unpacked to disk and never loaded whole.
  * Every entry is hashed incrementally as it streams. Only small JSON
  * candidates (at most MAX_CANDIDATE_JSON_BYTES) are buffered for parsing,
@@ -51,6 +55,7 @@ import { combineEntryDigests } from "./contents-hash.js";
 import type {
   AnchorWitnessFile,
   CeilingFile,
+  FloorHeaderFile,
   ArtifactRecord,
   AuditFinding,
   BundleManifest,
@@ -108,6 +113,8 @@ const BUNDLE_VERSION = "bitgraph-bundle/1";
 const WITNESS_VERSION = "bitgraph-anchor-witness/1";
 const CEILING_VERSION_TAG = "bitgraph-ceiling/1";
 const CEILING_STATUS_VERSION_TAG = "bitgraph-ceiling-status/1";
+/** A Base floor block's header, beside the proof that signs it (the carrier/3 unpacker writes these). */
+export const FLOOR_HEADER_VERSION = "bitgraph-floor-header/1";
 /** Every export format starts with this; only EXPORT_FORMAT ("bitgraph-export/1") is checked. */
 const EXPORT_FORMAT_PREFIX = "bitgraph-export/";
 
@@ -369,6 +376,7 @@ function finalizeIngest(params: FinalizeParams): IngestResult {
   const witnesses: AnchorWitnessFile[] = [];
   const ceilings: CeilingFile[] = [];
   const ceilingStatuses: CeilingFile[] = [];
+  const floorHeaders: FloorHeaderFile[] = [];
   const exportFiles: ExportFile[] = [];
   const artifactsByHex = new Map<string, ArtifactRecord>();
   let manifest: ManifestReport | undefined;
@@ -481,6 +489,11 @@ function finalizeIngest(params: FinalizeParams): IngestResult {
 
     // A ceiling in time travels beside its proof: evidence, never an artifact.
     const pv = parsed !== undefined ? (parsed as Record<string, unknown>)["version"] : undefined;
+    // So does a Base floor block's header: evidence for the temporal stage.
+    if (pv === FLOOR_HEADER_VERSION) {
+      floorHeaders.push({ path: entry.path, fileSha256Hex: entry.sha256Hex, json: parsed as Record<string, unknown> });
+      continue;
+    }
     if (pv === CEILING_VERSION_TAG || pv === CEILING_STATUS_VERSION_TAG) {
       (pv === CEILING_VERSION_TAG ? ceilings : ceilingStatuses).push({
         path: entry.path,
@@ -517,6 +530,7 @@ function finalizeIngest(params: FinalizeParams): IngestResult {
     unsupportedVersion: unsupportedVersions.length,
     artifacts: artifacts.length,
     witnesses: witnesses.length,
+    ...(floorHeaders.length > 0 ? { floorHeaders: floorHeaders.length } : {}),
     ceilings: ceilings.length + ceilingStatuses.length,
     exports: exportFiles.length,
     skippedUnsafePaths,
@@ -531,6 +545,7 @@ function finalizeIngest(params: FinalizeParams): IngestResult {
     unsupportedVersions,
     artifacts,
     witnesses,
+    ...(floorHeaders.length > 0 ? { floorHeaders } : {}),
     ceilings,
     ceilingStatuses,
     exports: exportFiles,

package/src/report-json.ts

@@ -128,6 +128,8 @@ export function buildJsonReport(result: AuditResult): AuditJsonReport {
       segments: result.temporal.segments,
       verifiedAnchorProofHashes: result.temporal.verifiedAnchorProofHashes,
       unverifiedAnchorProofHashes: result.temporal.unverifiedAnchorProofHashes,
+      ...(result.temporal.signedFloors !== undefined ? { signedFloors: result.temporal.signedFloors } : {}),
+      ...(result.temporal.floorProblems !== undefined ? { floorProblems: result.temporal.floorProblems } : {}),
     },
     summary,
   };
@@ -287,6 +289,8 @@ function buildSummary(
     if (proof.measurement !== undefined) measurements.add(proof.measurement);
   }
 
+  const floors = result.temporal.signedFloors ?? [];
+  const floorProblems = result.temporal.floorProblems ?? [];
   const segmentCount = (status: TemporalSegmentStatus): number =>
     result.temporal.segments.filter((s) => s.status === status).length;
 
@@ -333,6 +337,17 @@ function buildSummary(
       segmentsLowerBounded: segmentCount("lower-bounded"),
       segmentsUpperBounded: segmentCount("upper-bounded"),
       segmentsUnanchored: segmentCount("ordered-but-unanchored"),
+      ...(floors.length > 0 || floorProblems.length > 0
+        ? {
+            baseFloors: {
+              signed: floors.length,
+              bounding: floors.filter((f) => f.bound === "not-before").length,
+              headersChecked: floors.filter((f) => f.header === "checked").length,
+              withheld: floors.filter((f) => f.bound === "withheld").length,
+              problems: floorProblems.length,
+            },
+          }
+        : {}),
     },
     ...(exportChecks.length > 0
       ? {

package/src/report-md.ts

@@ -390,41 +390,51 @@ function executiveSummary(
   lines.push("### External time evidence");
   lines.push("");
   const t = s.temporal;
-  if (t.anchorsIdentified === 0) {
+  const bf = t.baseFloors;
+  if (t.anchorsIdentified === 0 && bf === undefined) {
     lines.push(
       "No Ethereum anchor proofs were observed. The causal order of the " +
         "proofs stands on its own; this report makes no wall-clock claims."
     );
     lines.push("");
   } else {
-    lines.push(
-      `${withCommas(t.anchorsIdentified)} Ethereum anchor ${plural(t.anchorsIdentified, "proof was", "proofs were")} ` +
-        "identified. An anchor is an ordinary chain member that committed " +
-        "the fingerprint of a public Ethereum block, giving the chain a " +
-        "contact point with a public timeline. " +
-        `${withCommas(t.anchorsWithVerifiedWitness)} ${plural(t.anchorsWithVerifiedWitness, "anchor", "anchors")} ` +
-        "came with witness material (the block header) that let this tool " +
-        "reconstruct the block fingerprint locally and confirm it against " +
-        "the signed anchor, entirely offline."
-    );
-    lines.push("");
-    lines.push(
-      "A verified anchor bounds time in one direction at a time. Proofs " +
-        "that come after an anchor in the chain were committed no earlier " +
-        "than that block's timestamp, because the block's fingerprint " +
-        "could not have been known before the block existed. That lower " +
-        "bound additionally assumes the anchored header is a genuine, " +
-        "publicly published Ethereum block: this offline audit checks the " +
-        "header's structure and hash binding, not proof-of-work, " +
-        "consensus, or chain membership, so it cannot confirm the block " +
-        "is real. Proofs that come before an anchor existed before the " +
-        "commit that consumed the block; reading that as a wall-clock " +
-        "ceiling additionally assumes the anchor consumed a recently " +
-        "published block. Every such bound in this report states its " +
-        "assumption. No individual proof's exact creation time is ever " +
-        "stated."
-    );
-    lines.push("");
+    if (t.anchorsIdentified > 0) {
+      lines.push(
+        `${withCommas(t.anchorsIdentified)} Ethereum anchor ${plural(t.anchorsIdentified, "proof was", "proofs were")} ` +
+          "identified. An anchor is an ordinary chain member that committed " +
+          "the fingerprint of a public Ethereum block, giving the chain a " +
+          "contact point with a public timeline. " +
+          `${withCommas(t.anchorsWithVerifiedWitness)} ${plural(t.anchorsWithVerifiedWitness, "anchor", "anchors")} ` +
+          "came with witness material (the block header) that let this tool " +
+          "reconstruct the block fingerprint locally and confirm it against " +
+          "the signed anchor, entirely offline."
+      );
+      lines.push("");
+      lines.push(
+        "A verified anchor bounds time in one direction at a time. Proofs " +
+          "that come after an anchor in the chain were committed no earlier " +
+          "than that block's timestamp, because the block's fingerprint " +
+          "could not have been known before the block existed. That lower " +
+          "bound additionally assumes the anchored header is a genuine, " +
+          "publicly published Ethereum block: this offline audit checks the " +
+          "header's structure and hash binding, not proof-of-work, " +
+          "consensus, or chain membership, so it cannot confirm the block " +
+          "is real. Proofs that come before an anchor existed before the " +
+          "commit that consumed the block; reading that as a wall-clock " +
+          "ceiling additionally assumes the anchor consumed a recently " +
+          "published block. Every such bound in this report states its " +
+          "assumption. No individual proof's exact creation time is ever " +
+          "stated."
+      );
+      lines.push("");
+    } else {
+      lines.push(
+        "No Ethereum anchor proofs were observed. After the cutover to Base floors (enclave v10) there " +
+          "are none: order after a record is the chain of proof hashes."
+      );
+      lines.push("");
+    }
+    if (bf !== undefined) baseFloorSummary(lines, report);
     lines.push(
       ...table(
         ["Temporal coverage", "Segments"],
@@ -440,6 +450,50 @@ function executiveSummary(
   }
 }
 
+/** The executive summary's paragraph on Base floors (enclave v10). Only written when a proof signs one or a floor problem was found. */
+function baseFloorSummary(lines: string[], report: AuditJsonReport): void {
+  const bf = report.summary.temporal.baseFloors;
+  if (bf === undefined) return;
+  if (bf.signed > 0) {
+    const rest = bf.signed - bf.headersChecked;
+    lines.push(
+      `${withCommas(bf.signed)} ${plural(bf.signed, "proof signs", "proofs sign")} a Base block as ` +
+        `${plural(bf.signed, "its", "their")} floor (commit.slotFloor, enclave v10). A proof that signs a floor was ` +
+        "committed no earlier than that block's time: the block's hash could not exist before the block, and the " +
+        "proof signs it. Proofs after it in the chain carry the same bound. A floor is a lower bound only: it " +
+        "bounds nothing from above, and it orders no epoch. " +
+        `${withCommas(bf.headersChecked)} of ${withCommas(bf.signed)} came with the block's header, checked against ` +
+        "the signed hash, number and time" +
+        (rest > 0
+          ? `; for the other ${withCommas(rest)} the time is the one the proof signs, on Base mainnet's schedule for ` +
+            "that block, and confirming the block needs a Base lookup. "
+          : ". ") +
+        "Like an anchored block, a floor additionally assumes the block is a genuine, publicly published Base " +
+        "block, which this offline audit cannot confirm." +
+        (bf.withheld > 0
+          ? ` ${withCommas(bf.withheld)} ${plural(bf.withheld, "floor is", "floors are")} not used as a bound; ` +
+            "the reasons are in the temporal bounds section."
+          : "")
+    );
+    lines.push("");
+  }
+  const problems = report.temporal.floorProblems ?? [];
+  if (problems.length > 0) {
+    lines.push(
+      `${withCommas(problems.length)} floor ${plural(problems.length, "problem was", "problems were")} found ` +
+        "(exit bit 2). A floor with a problem bounds nothing:"
+    );
+    lines.push("");
+    for (const p of problems.slice(0, MAX_TABLE_ROWS)) {
+      lines.push(
+        `- ${inlineCode(p.code)}${p.path !== undefined ? ` ${inlineCode(p.path)}` : ""}` +
+          `${p.proofHash !== undefined ? `, proof ${inlineCode(p.proofHash)}` : ""}: ${p.message}`
+      );
+    }
+    lines.push("");
+  }
+}
+
 /** Plain sentences describing one partition's chain state, in the brief's style. */
 function partitionSummarySentences(report: AuditJsonReport, partition: ReportPartition): string[] {
   const out: string[] = [];
@@ -841,6 +895,22 @@ function temporalDetails(lines: string[], report: AuditJsonReport): void {
     }
     lines.push("");
   }
+  const floors = report.temporal.signedFloors ?? [];
+  if (floors.length > 0) {
+    lines.push("Base floors the proofs sign (enclave v10), each a not-before for its proof and never an upper bound:");
+    lines.push("");
+    for (const f of floors.slice(0, MAX_TABLE_ROWS)) {
+      lines.push(
+        `- Base block ${withCommas(f.blockNumber)} (${formatTimestamp(f.blockTimestamp)}, hash ${inlineCode(f.blockHash)}), ` +
+          `signed by ${inlineCode(f.proofHash)}: ` +
+          (f.header === "checked"
+            ? `header checked (${inlineCode(f.headerPath ?? "")})`
+            : "no header in the bundle; confirming the block needs a Base lookup") +
+          (f.bound === "not-before" ? "; bounds the proof not before that time." : `; not used as a bound: ${f.withheldReason ?? "withheld"}.`)
+      );
+    }
+    lines.push("");
+  }
   if (report.epochRelationships.anchorOrderedPairs.length > 0) {
     lines.push("Anchor-derived epoch ordering (assumption-dependent, covered portions only):");
     lines.push("");
@@ -859,6 +929,13 @@ function temporalDetails(lines: string[], report: AuditJsonReport): void {
 }
 
 function boundLine(bound: SegmentBound): string {
+  if (bound.source === "signed-floor") {
+    return (
+      `Committed no earlier than ${formatTimestamp(bound.timestamp)} ` +
+      `(Base block ${bound.blockNumber ?? "?"}, the floor signed by ${inlineCode(bound.anchorProofHash)}, ` +
+      `evidence: ${bound.evidence}${bound.weaker ? ", weaker" : ""}). ${bound.claim}`
+    );
+  }
   const direction =
     bound.kind === "not-before"
       ? "Committed no earlier than"
@@ -1005,12 +1082,13 @@ function exportDetail(lines: string[], e: ExportCheck): void {
   const t = e.times;
   lines.push(
     t.floor !== null
-      ? `- Floor: Ethereum block ${withCommas(t.floor.blockNumber)}, mined at ${formatTimestamp(t.floor.blockTimestamp)}, ` +
+      ? `- Floor: ${t.floor.chain === "base" ? "Base" : "Ethereum"} block ${withCommas(t.floor.blockNumber)}, ` +
+          `${t.floor.chain === "base" ? "stamped" : "mined"} at ${formatTimestamp(t.floor.blockTimestamp)}, ` +
           `hash ${inlineCode(t.floor.blockHash)}: the proof's signed floor block, its header checked by hash. ` +
           "Every file in the tree was recorded after it (the record floor). Committed bytes that carry this position's " +
           "commitment were also finished after it (the content floor); an original inside them, and a file recorded as is, " +
           "are not dated by it. What the floor covers for each file is stated per run below." +
-          confirmedNote("confirmed.floor", "Ethereum")
+          confirmedNote("confirmed.floor", t.floor.chain === "base" ? "Base" : "Ethereum")
       : `- Floor: not established (${why("floor.header")}).`
   );
   lines.push(