@sanning/proof 0.7.0 → 0.8.1

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { ACCEPTED_SPEC_MAJORS, contentHashes, jcs, specVersionSupported, verifyE
 export { bytesToHex, deriveOperatorAddress, ed25519Verify, hexToBytes, sha256Bytes, sha256Hex, utf8, verifyRsaPssSha256, } from "./crypto.js";
 export { EMPTY_TREE_ROOT_HEX, auditPath, leafHash, merkleRoot, nodeHash, verifyInclusion, } from "./merkle.js";
 export type { ContentRole, Envelope, Subject, VerificationResult, VerifyOptions } from "./types.js";
-export { ANCHOR_TRACE_BODY_TYPE, ANCHOR_TRACE_BODY_TYPE_V1, ANCHOR_TRACE_BODY_TYPES, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
-export type { AnchorTraceBody, AttestationPayload, AttestationRecord, AttestationResult, CheckpointResult, ComposeVerdictResult, DisclosedContentResult, DisclosedEventContent, DisclosureStatus, EvidenceBundle, EvidenceBundleResult, EvidenceIssuer, EvidenceStatus, EvidenceVerdict, EventResult, ExportBody, ExportResult, OnChainOutcome, OnChainResult, PerGatewayOutcome, AnchorRef, StampBody, StampEntry, StampResult, StampSubtree, StampSubtreeResult, StampTraceBody, TraceCheckpoint, TraceCheckpointV1, TraceEvent, TraceInclusion, VerdictAttestation, VerdictCheckpoint, VerdictEvent, VerdictObject, VerdictOnChain, VerdictOnChainGateway, VerifyEvidenceOptions, } from "./evidence.js";
+export { ANCHOR_TRACE_BODY_TYPE, ANCHOR_TRACE_BODY_TYPE_V1, ANCHOR_TRACE_BODY_TYPES, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, STAMP_EVIDENCE_BODY_TYPE, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
+export type { AnchorTraceBody, AttestationPayload, AttestationRecord, AttestationResult, CheckpointResult, ComposeVerdictResult, DisclosedContentResult, DisclosedEventContent, DisclosureStatus, EvidenceBundle, EvidenceBundleResult, EvidenceIssuer, EvidenceStatus, EvidenceVerdict, EventResult, ExportBody, ExportResult, OnChainOutcome, OnChainResult, PerGatewayOutcome, AnchorRef, StampBody, StampEntry, StampResult, StampSubtree, StampSubtreeResult, StampTraceBody, StampEvidenceBody, StampEvidenceEvent, StampEvidenceInclusion, TraceCheckpoint, TraceCheckpointV1, TraceEvent, TraceInclusion, VerdictAttestation, VerdictCheckpoint, VerdictEvent, VerdictObject, VerdictOnChain, VerdictOnChainGateway, VerifyEvidenceOptions, } from "./evidence.js";
 export { accountDisclosure, completenessNotes, gradeCauses, gradePack, renderCause, signedLeafCount, } from "./grading.js";
 export type { CompletenessNote, DisclosureAccount, GradeInput, PackGrade, PackGradeCause, PackGradeCauseKind, PackVerdict, } from "./grading.js";
 export { ADAPTER_CHAIN_NAMESPACES, CHAIN_READING_SCOPE, readChains, renderChainFinding, } from "./chain.js";

package/dist/index.js

@@ -34,7 +34,7 @@ export { EMPTY_TREE_ROOT_HEX, auditPath, leafHash, merkleRoot, nodeHash, verifyI
 // files that failed verification on genuine evidence. This hands back DECODED
 // bytes, and only for events whose verification bound them to the committed
 // content_hash. Additive; verifyEvidenceBundle's behavior is unchanged.
-export { ANCHOR_TRACE_BODY_TYPE, ANCHOR_TRACE_BODY_TYPE_V1, ANCHOR_TRACE_BODY_TYPES, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
+export { ANCHOR_TRACE_BODY_TYPE, ANCHOR_TRACE_BODY_TYPE_V1, ANCHOR_TRACE_BODY_TYPES, EXPORT_BODY_TYPE, STAMP_BODY_VERSION, STAMP_TRACE_BODY_TYPE, STAMP_EVIDENCE_BODY_TYPE, disclosedContent, recomputeExportVerdict, verifyEvidenceBundle, } from "./evidence.js";
 // Pack grading (src/grading.ts): what a verification SURFACE may claim about a
 // pack — the signed bundle PLUS whatever disclosed bytes travelled beside it.
 //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanning/proof",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "TypeScript kernel of the Sanning verification stack: RFC 8785 (JCS) canonicalization, SHA-256, and Ed25519 verification for Verifiable Event Envelopes. Full-family verifier (inline + external commitment); accepts sanning.agent/v1, sanning.mlflow/v1, sanning.events/v1. Conformance-gated byte-for-byte against the test-vectors corpus.",
   "license": "MIT",
   "type": "module",

package/src/chain.ts

@@ -236,7 +236,15 @@ function adapterLinkage(
     // here: nothing to resolve is a beginning.
     const prev = str(fields.prev_event_id);
     const seqRaw = fields.seq;
-    const seq = Number.isInteger(seqRaw) ? (seqRaw as number) : null;
+    // SAFE integer, not merely integral. Beyond 2^53 a JSON number does not
+    // survive `JSON.parse` intact — `9007199254740993` arrives as
+    // `...992` — while Python's parser keeps it exactly, so the two kernels
+    // read DIFFERENT sequence numbers off identical bytes and report gaps of
+    // different widths. Measured at 2^53+1: a `chain-gap` count of
+    // 9007199254740990 here against 9007199254740992 there (proof#49). A value
+    // this kernel cannot represent is one it cannot read, which is the same
+    // answer it gives every other unreadable field: no sequence, take no part.
+    const seq = Number.isSafeInteger(seqRaw) ? (seqRaw as number) : null;
     return { namespace, chainKey, prev, seq };
   }
   return null;
@@ -322,6 +330,20 @@ function byChainOrder(a: Member, b: Member): number {
   return a.order - b.order;
 }
 
+/**
+ * The smallest slot between the lowest and highest occupied ones that no record
+ * occupies, found by walking the SORTED occupants rather than the range they
+ * span. See the call site: the range's width is chosen by whoever wrote the
+ * bundle.
+ */
+function firstMissingSlot(present: Set<number>): number | null {
+  const ordered = [...present].sort((a, b) => a - b);
+  for (let i = 0; i < ordered.length - 1; i++) {
+    if (ordered[i + 1]! > ordered[i]! + 1) return ordered[i]! + 1;
+  }
+  return null;
+}
+
 function findingsFor(group: Group): ChainFinding[] {
   const { members, chainKey, source, publicKey } = group;
   const of = members.length;
@@ -383,16 +405,23 @@ function findingsFor(group: Group): ChainFinding[] {
     const present = new Set(sequenced.map((m) => m.seq as number));
     const low = Math.min(...present);
     const high = Math.max(...present);
-    const missing: number[] = [];
-    for (let s = low; s <= high; s++) if (!present.has(s)) missing.push(s);
-    if (missing.length > 0) {
-      const after = sequenced.filter((m) => (m.seq as number) > missing[0]!).sort(byChainOrder)[0];
+    // Counted, never walked. `seq` is attacker-chosen, so a bundle presenting
+    // two records at seq 0 and seq 1e15 made the old `for (let s = low; s <=
+    // high; s++)` spin for days — a verifier that HANGS on adversarial input is
+    // worse than one that raises, and this reader promises neither (proof#49).
+    // The present set is a subset of [low, high], so the absent slots are the
+    // width minus the occupants, and the first of them is found by walking the
+    // occupants in order.
+    const missingCount = high - low + 1 - present.size;
+    const firstMissing = missingCount > 0 ? firstMissingSlot(present) : null;
+    if (firstMissing !== null) {
+      const after = sequenced.filter((m) => (m.seq as number) > firstMissing).sort(byChainOrder)[0];
       findings.push({
         kind: "chain-gap",
         ...base,
-        count: missing.length,
+        count: missingCount,
         eventIds: after === undefined ? [] : [after.eventId],
-        firstMissingSeq: missing[0]!,
+        firstMissingSeq: firstMissing,
       });
     }
   }
@@ -411,7 +440,18 @@ function findingsFor(group: Group): ChainFinding[] {
 export async function readChains(bundle: unknown): Promise<ChainReading> {
   const groups = await groupChains(bundle);
   const order = (g: Group) => `${g.source} ${g.namespace ?? ""} ${g.chainKey}`;
-  groups.sort((a, b) => order(a).localeCompare(order(b)));
+  // Ordered by UTF-16 code unit, NOT `localeCompare`. A chain key is caller
+  // text, and `localeCompare` with no locale argument answers from the host's
+  // ICU collation: measured here, it puts "chain-2" AFTER "chain_1" where every
+  // code-wise comparison puts it before, and it can differ between two
+  // TypeScript installs, let alone between kernels. The Python reader sorts the
+  // same key encoded as `utf-16-be`, which is exactly this comparison — so the
+  // two kernels emit findings in one order (proof#49).
+  groups.sort((a, b) => {
+    const x = order(a);
+    const y = order(b);
+    return x < y ? -1 : x > y ? 1 : 0;
+  });
 
   return {
     chains: groups.map((g) => ({

package/src/cli.ts

@@ -697,6 +697,35 @@ function reportEvidence(
     }
   }
 
+  // Stamps (evidence-bundle.md §5.2 / §5.3). Printed rather than summarised,
+  // because for a stamp body the WITNESS is the entire independent part
+  // (§5.2.4) — and until now this reporter showed nothing about it at all, so a
+  // §5.3 pack printed a rollup line claiming an on-chain scope with no visible
+  // on-chain result anywhere above it.
+  //
+  // The on-chain column distinguishes all four states in the same three
+  // characters the checkpoint block uses, plus its absence: `✓` confirmed,
+  // `✗` mismatched, `~` asked and unreachable, and NO COLUMN AT ALL when
+  // nothing was checked. A reader must never have to infer "not checked" from
+  // a symbol that also means "could not be reached".
+  if (result.stamps && result.stamps.length > 0) {
+    io.out("");
+    io.out(paint("  Stamps", DIM));
+    for (const st of result.stamps) {
+      const witness =
+        st.anchorRef === null
+          ? paint("~ no witness", Y)
+          : `witness ${st.anchorRef.kind}:${shortTx(st.anchorRef.id)}`;
+      const onChain =
+        st.onChain === null ? "" : `  on-chain ${mark(st.onChainOk)} (${st.onChain.rollup})`;
+      io.out(
+        `    ${mark(st.ok)} ${shortTx(st.stampRef)}  bytes ${mark(st.stampRefOk && st.bodyOk)}` +
+          `  ranges ${mark(st.subtreesOk)}  ${witness}${onChain}`,
+      );
+      for (const e of st.errors) io.out(paint(`        - ${e}`, R));
+    }
+  }
+
   if (result.events.length > 0) {
     io.out("");
     io.out(paint("  Events", DIM));