The artifacts
What each check proves
- Checkpoint signature: the checkpoint was signed by Attesso’s log key and the signed bytes are exactly what you received. A checkpoint nobody can forge is what makes every later comparison meaningful.
- Consistency: the tree you saved is contained in the newer tree, leaf for leaf and in order. If a single history leaf had been changed or removed, no consistency proof could exist. This is the check that catches rewrites and omissions.
- Inclusion: each of your mandate’s events is a leaf of the checkpointed tree at the position the proof names. The events themselves come from the evidence bundle you hold; the record proof shows they were committed.
- Time anchor (when present): the checkpoint’s hash was timestamped by an
independent RFC 3161 authority at
gen_time, so the checkpoint existed by that moment regardless of Attesso’s key.
The signed checkpoint
payload decodes to this canonical JSON; the signature covers these exact
bytes:
tree_sizecounts every event in the log up to this checkpoint.root_hashis the RFC 6962 root over the leaves.prev_hashchains each checkpoint to its predecessor, so a set of checkpoints you collected over time also forms a chain.
SHA-256(0x00 || digest), interior nodes are
SHA-256(0x01 || left || right), and a record proof’s event_digest field
is sha256:<digest hex>.
The time anchor
anchors carries the RFC 3161 time anchors collected for a checkpoint, one
object per token. A token is signed by a Time-Stamp Authority over the
checkpoint’s hash. It is the independent half of the record: Attesso’s key
alone could sign a backdated checkpoint, but a token from an authority that
never spoke to Attesso fixes the checkpoint’s existence at a moment it
attests.
token from standard base64 to a
.tsr file, then inspect it with OpenSSL.
payload you hold (SHA-256 over the decoded payload bytes). Whether you
trust that authority is your policy, not Attesso’s: check the token against
the TSA’s published certificate, or treat it as a second signature over the
same bytes. An unanchored checkpoint serves "anchors": [], and that is
honest: the worker anchors on its next cycle when an authority is reachable.
Verify it (Go, standard library only)
check-the-record.go is the runnable recipe: it takes the artifacts above and
prints one OK or FAIL line per check. Download it, then:
When the record proof lags
record-proof reports pending_events: the mandate’s events not yet covered
by a published checkpoint (journal lag plus checkpoint lag). A non-zero count
is normal right after activity; fetch again once the next checkpoint exists.
checkpoint is null until the log’s first checkpoint, and inclusion proofs
only exist for events the checkpoint covers.
Limits
- The record proves the log only grows and that what you saw earlier is still contained. It is a point-in-time guarantee: re-check the latest checkpoint to extend it.
- Checkpoints are signed by one published key; the keys page
(
/.well-known/record-log-jwks.json) retains rotated keys for the evidence-retention period. A compromised key can forge checkpoints until rotation; your previously saved checkpoints and theprev_hashchain still pin the earlier history. - Attesso fetches fresh proofs for you today. The proofs are offline verifiable, which is what makes them worth collecting.

