SSMDE – Stamp (1.4)

Proof of when this statement existed, and in what order

What a stamp is

A stamp turns a reading into evidence by binding:

  • time (human-checkable),
  • content (digest of canonical bytes),
  • order (link to previous digest).

Typical shape:

SSMCLOCK1|<utc>|theta=<deg>|sha256=<hex>|prev=<hex-or-NONE>
  • utc — an ISO-like UTC time.
  • theta — any monotonic marker available (e.g., rotation/sequence/frame).
  • sha256 — digest of the canonical record subset.
  • prev — the previous record’s digest (or NONE for the first record).

Why it matters

  • Integrity: if bytes change, the digest won’t match.
  • Ordering: removing/reordering a record breaks the prev chain.
  • Replayability: anyone can re-hash the same canonical content offline and verify.

Canonical content (make the hash stable)

Publish exactly what you hash; keep it tiny and deterministic.

Example canonical subset (copy-ready):

canonical(record):
  {
    "value":       <as-emitted>,
    "align":       <number>,
    "band":        <string-or-null>,
    "manifest_id": <string>
  }

Serialization rules (recommendation):

• UTF-8
• no trailing spaces
• stable field order: value, align, band, manifest_id
• integers/floats in plain ASCII (no locale commas)
• true/false/null in lowercase ASCII if used

Digest:

digest := sha256( bytes(canonical(record)) )

Emitting a stamp (sender)

prev := "NONE"

emit(record):
  cbytes  := bytes( canonical(record) )
  digest  := sha256(cbytes)
  stamp   := "SSMCLOCK1|" + utc_now() +
             "|theta=" + monotonic_marker() +
             "|sha256=" + digest +
             "|prev=" + prev
  record.stamp := stamp
  prev := digest
  send(record)

Verifying a stamp (receiver or auditor)

verify(stream):
  prev_check := "NONE"
  for r in stream_in_arrival_order:
      cbytes := bytes( canonical(r) )
      expect := sha256(cbytes)

      # 1) digest parity
      assert parse(r.stamp, "sha256") == expect

      # 2) chain continuity
      assert parse(r.stamp, "prev") == prev_check

      prev_check := expect

Pass ⇒ content is intact and ordering is unbroken.

Failure signatures (what they mean)

digest mismatch  → someone edited content after stamping
prev mismatch    → record removed/reordered or wrong chain head
time anomaly     → clock skew; verify against independent references
theta jump back  → non-monotonic source; treat as health signal

Resilience patterns

Outage buffering

# keep local chain even if upstream link drops
append(local_ledger.jsonl, record)

Sharding → merging

# each shard has its own chain; when merging, retain shard heads & order by utc
# (do not re-stamp old records; publish a merge-manifest describing ordering)

Clock discipline

# if clock is corrected, annotate with an out-of-band health flag
health.clock_adjusted := true

Minimal, copy-ready example

{
  "value": { "temperature_K": 296.42 },
  "align": 0.87,
  "band":  "GREEN",
  "manifest_id": "THERMAL_LINE_COOLING_PLANT_A_v7",
  "stamp": "SSMCLOCK1|2025-11-04T11:22:33Z|theta=132.77|sha256=9fde1c...|prev=72af0b..."
}

Checklist (publishers and reviewers)

[ ] canonical(record) is documented and stable
[ ] sha256(canonical(record)) equals stamp.sha256
[ ] first record uses prev=NONE (or declared chain head)
[ ] each next record’s prev equals prior digest
[ ] utc and theta fields are present and sensible

Navigation

Previous: SSMDE – Manifest (1.3)
Next: SSMDE – Putting it together (1.5)

Directory of Pages
SSMDE – Table of Contents