@sanning/proof 0.7.0 → 0.8.1

package/dist/chain.js

@@ -143,7 +143,15 @@ function adapterLinkage(record) {
         // here: nothing to resolve is a beginning.
         const prev = str(fields.prev_event_id);
         const seqRaw = fields.seq;
-        const seq = Number.isInteger(seqRaw) ? seqRaw : 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 : null;
         return { namespace, chainKey, prev, seq };
     }
     return null;
@@ -226,6 +234,20 @@ function byChainOrder(a, b) {
         return a.seq - b.seq;
     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) {
+    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) {
     const { members, chainKey, source, publicKey } = group;
     const of = members.length;
@@ -283,18 +305,23 @@ function findingsFor(group) {
         const present = new Set(sequenced.map((m) => m.seq));
         const low = Math.min(...present);
         const high = Math.max(...present);
-        const missing = [];
-        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 > 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 > 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,
             });
         }
     }
@@ -311,7 +338,18 @@ function findingsFor(group) {
 export async function readChains(bundle) {
     const groups = await groupChains(bundle);
     const order = (g) => `${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) => ({
             chainKey: g.chainKey,

package/dist/cli.js

@@ -610,6 +610,31 @@ function reportEvidence(result, path, gateways, io, chains) {
                 io.out(paint(`        - ${e}`, R));
         }
     }
+    // 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));

package/dist/evidence.d.ts

@@ -25,6 +25,7 @@ export declare const EXPORT_BODY_TYPE = "sanning.evidence.export/v1";
  * unrecoverable once witnessed.
  */
 export declare const STAMP_TRACE_BODY_TYPE = "sanning.stamp.trace/v1";
+export declare const STAMP_EVIDENCE_BODY_TYPE = "sanning.stamp.evidence/v1";
 /**
  * The version string INSIDE a witnessed stamp body — a different string from
  * the `body_type` above, and the two are easy to confuse.
@@ -162,6 +163,26 @@ export interface StampEntry {
 export interface StampTraceBody {
     stamps: StampEntry[];
 }
+/** §5.3's inclusion: §5.1's shape with `stamp_ref` as the join key. */
+export interface StampEvidenceInclusion {
+    leaf_hash: string;
+    leaf_index: number;
+    leaf_count: number;
+    audit_path: string[];
+    /** Resolves against `stamps[].stamp_ref` in the SAME body. */
+    stamp_ref: string;
+}
+export interface StampEvidenceEvent {
+    envelope: Envelope;
+    record_bytes?: string;
+    content?: string;
+    inclusion: StampEvidenceInclusion;
+}
+export interface StampEvidenceBody {
+    /** Byte-identical to §5.2.2 — one definition, one place to change. */
+    stamps: StampEntry[];
+    events: StampEvidenceEvent[];
+}
 export interface EvidenceBundle {
     spec_version: string;
     body_type: string;
@@ -271,6 +292,35 @@ export interface StampResult {
      * carries it.
      */
     anchorRef: AnchorRef | null;
+    /**
+     * Per-gateway on-chain outcomes for this stamp's `anchor_ref` (§4.2's shape,
+     * `checkpoints[]`'s vocabulary), or `null` when NOTHING WAS CHECKED.
+     *
+     * ── The four states, and why none of them collapses ──
+     *
+     * `null` means not checked — no gateways were supplied, or this stamp names
+     * no witness to check. It is a statement about the RUN, never about the
+     * stamp. The other three are statements about the stamp and live in
+     * `onChain.rollup`: `confirm` (a gateway returned the witnessed bytes),
+     * `mismatch` (a gateway returned DIFFERENT bytes — a finding, and the only
+     * one of the four that fails anything), `unreachable` (we asked and nobody
+     * answered — an availability gap, never an accusation).
+     *
+     * Keeping "not checked" distinct from "unreachable" is the whole point. A
+     * surface handed a collapsed boolean cannot tell "no gateway could be
+     * reached" from "no gateway was tried", and reported the first when the
+     * second was true — a false accusation manufactured by a missing state.
+     */
+    onChain: OnChainResult | null;
+    /**
+     * Derived collapse of `onChain`, mirroring `CheckpointResult.onChainOk` so a
+     * consumer reads one field the same way on both: `false` on mismatch, `true`
+     * on confirm, `null` on unreachable AND on not-checked.
+     *
+     * It is deliberately the LOSSY view — `null` is three-quarters of the state
+     * space here. Anything that needs to tell those apart reads `onChain`.
+     */
+    onChainOk: boolean | null;
     ok: boolean;
     errors: string[];
 }