Knowledge Base

Browse the concepts behind Truestamp. Follow the links between concepts, or search across everything.

The Item Record and Its Hash

How an item's claims fingerprint, its id and its witness hashes are bound into one item record whose hash (item_hash) is the Merkle leaf, keeping user data independently verifiable, committing the witnesses of the submitted-after edge, and excluding authorship from every hash.

Overview

When you timestamp something with Truestamp, the item you submit is described by a small record of three members, the item record, and fingerprinted by its hash. The claims fingerprint (in code, claims_hash) covers exactly what you submitted and nothing else, so anyone holding a copy of the data can recompute and check it, with no trust in Truestamp required. The witness hashes (witness_hashes) name the item’s witnesses, the records that already existed at the moment you submitted: the block then at the head of Truestamp’s ledger and the newest entropy captured from each public source. The entropy witnesses could only be named after their sources published them, so they open the submitted-after edge of your submission window without ever touching your data. The item hash (item_hash) is the hash of the record {claims_hash, id, witness_hashes}: the single value Truestamp places as a leaf in its internal Merkle tree, inside a block that is later committed to a public blockchain. Items are not signed; the block that holds the leaf is. This document explains what each part covers, why the work is split this way, and why who authored an item is never part of any of them.

What each fingerprint covers

Truestamp computes an item’s record and its hash in order.

  • Claims fingerprint (claims_hash). A SHA-256 hash over your submitted data (your “claims”) after that data is put into a single canonical byte-for-byte form. It covers only what you sent: a name, an optional external file hash and its algorithm, an optional description, URL, geographic location, your own timestamp, and any freeform fields. Nothing the system adds is mixed in here, so you can reproduce this hash from your own copy of the data at any time.
  • Witness hashes (witness_hashes). A small system-generated map that captures the moment of submission: one hash per witness, naming the public records that already existed when you submitted. It always names the block then at the head of Truestamp’s internal chain (block), and it names the newest observation captured from each public randomness source whose observation could be read, from the NIST Randomness Beacon, the Stellar ledger, and the Bitcoin blockchain. It commits which records preceded your submission without touching your data. The submission moment is an instant Truestamp records, not an instant it proves; what a verifier establishes is the submission window, whose submitted-after edge the entropy witnesses open.
  • Item hash (item_hash). A SHA-256 hash under the prefix 0x11 over the canonical form of the item record, which has exactly three members: the claims fingerprint, the item’s identifier, and the witness hashes. The item hash is the value that becomes a leaf in Truestamp’s internal Merkle tree. Because the record holds both the claims fingerprint and the witness hashes, it commits to your data and the submission timing at once. No key ID is a member, and items are not signed.

Each hash uses a distinct one-byte domain-separation prefix so that a hash computed for one purpose can never be mistaken for a hash computed for another: the claims fingerprint (0x10) and the item hash (0x11) each reserve their own prefix byte. The mechanics of that prefixing are covered in the hashing and domain separation concept, and the full list of reserved prefix bytes is in the byte-prefix registry. Entropy observations follow the same pattern under their own prefixes, and blocks hash a block record of their own.

Kept apart, bound together

Splitting the work into a claims fingerprint, a witness map and one record over both keeps three concerns cleanly separated, which a single hash over everything could not do.

  • Your data is hashed alone and can be checked independently. Because the claims fingerprint is computed over exactly what you submitted and nothing else, you never have to trust Truestamp to reproduce it. You take your own copy of the claims, put it into the same canonical form, hash it, and compare it to the stored claims fingerprint to confirm nothing changed. Separately, if you submitted an external file’s hash as part of your claims, that same hash is stored inside your claims and is itself searchable: pasting it into the search page finds the public items whose claims carry it, plus, when you are signed in, the items you can read in your currently selected team, answering “do I already have a timestamp for this data”. If the system had folded values of its own into the claims fingerprint, you could not check it without also reconstructing everything the system added.
  • The submission window is committed on its own. The witness hashes record which public records preceded your submission. Keeping them in their own member means the timing evidence is committed to cryptographically, but it lives beside your data instead of inside it. It also means the evidence can travel: because the record is a small map of names to hashes rather than an opaque digest, a proof can carry the witnessed records themselves and let a verifier rehash each one. This is one half of the submission window described below.
  • One value carries everything into the tree. The item hash binds your claims fingerprint, the identifier and the witness hashes into a single leaf value. That gives the Merkle tree, and any later proof, exactly one hash to work with while still being tied back to both the data and the timing. Changing either your data or the recorded witnesses would change the item hash, and therefore the leaf, and therefore any inclusion proof over it. See inclusion proofs for how that leaf is later proven to belong to a block.

The submission window

The witness hashes are what let a proof support a submission window rather than a single instant. They name the records that already existed at the moment you submitted, so your item was submitted after each of them. Only the entropy witnesses give a time a stranger can confirm: a verifier reads each one again from the source that published it (a NIST pulse’s time stamp, a Stellar ledger’s close time, a Bitcoin block’s median time past), and the submitted-after edge is the latest of the times it confirms that way. The head block gives no edge at all, since no public source holds its time; it fixes where your submission sits in Truestamp’s ledger. Later, your item’s hash becomes a leaf of a finalized block, and that block is batched into an epoch whose hash Truestamp writes to Stellar or Bitcoin. The submitted-before edge is the earliest time a verifier reads for that write from the chain itself: your item was submitted before that Stellar ledger closed or that Bitcoin block was mined. Together these two edges, both drawn by the verifier from public sources it reads, make the submission window, not a claimed creation time. Truestamp proves when data was submitted, never when it was originally created.

A familiar picture makes the mechanism concrete: stapling a photo to today’s newspapers proves the bundle was put together after those papers were printed, and says nothing about when the photo’s subject was born. The witness hashes are the stack of newspapers, the claims fingerprint is the photo, and the item hash is the staple that makes the bundle inseparable. Several papers rather than one means that if a single publisher went quiet, its edition would be stale, and the freshest of the others still dates the bundle. The head block is the bundle’s own page number, not a newspaper: it says where the bundle sits in the stack, not when.

Authorship is never hashed

None of these hashes include who authored the item. The claims fingerprint covers only your submitted data. The witness hashes name only the submission-timing witnesses. The item hash covers the claims fingerprint, the identifier and the witness hashes, and nothing else. The account that ran the submission, the current owner of the item, and the team it lives in all sit outside every one of these hashes.

Because of this, an item’s hash stays stable even as ownership is reassigned or the item is moved between teams, so an inclusion proof made before such a change is still valid afterward. It also means the fingerprint makes no claim about authorship at all: proving an item is included in a block proves the data existed and when it was submitted, not who originally created it. The separation between an item’s immutable, audit-only authorship and its transferable ownership is covered in ownership versus authorship.

The preimage is the stored map, exactly as stored

The claims fingerprint and the item hash are each a hash over a whole map, canonicalized with JCS and prefixed with its domain byte. No field list is involved and there is no selection step: every key present in the stored claims contributes to the claims fingerprint, and every name present in the stored witness hashes contributes to the item hash. That is what lets anyone holding the stored values recompute both hashes and arrive at the same item hash the Merkle tree committed.

This places one invariant on the system: whatever reads a stored map back has to hand over the whole map. A read that narrows the map to some schema’s current field list would make the fingerprint depend on that schema rather than on the data, and the two kinds of change then differ. Adding a field stays safe, because an item that never carried it hashes identically either way. Removing or renaming one would retroactively change the recomputed hash of every item that did carry it, and those items were committed under the old name.

Truestamp therefore reads these maps back whole. Field-level validation still runs, but it runs on the way in, where a schema belongs: a map being written is checked before it is hashed (claims that break a rule are refused, never changed), so what is hashed and what is stored are the same bytes, and what is read back is those bytes again. The retrieval path holds no opinion about which keys the current schema happens to name.

The same rule covers every stored map a hash is computed over, not only an item’s. The entropy object an observation’s entropy hash covers, and the block record, its metadata included, that a block hash covers, are hashed and read back whole the same way.

Should a stored map ever stop reproducing its committed hash regardless, Truestamp treats that as a reason to refuse to generate a proof for the item, never as licence to issue a proof over the map it can currently see. Such a proof would carry a subject hash absent from the block’s Merkle tree, so no verifier could confirm it. See the proof lifecycle.

The item code

Every item also has an item code, a short name for people and links: the leftmost 75 bits of its item_hash as 15 symbols of the alphabet 0123456789ABCDEFGHJKMNPQRSTVWXYZ, followed by one check symbol, 16 uppercase characters with no separator. It is computed from the item hash and from nothing else, so no proof carries it and it never decides whether a proof passes; anything that needs to identify an item compares the whole item hash. How the code is computed, checked from a proof, issued and read is in the item code.

Limitations

  • The claims fingerprint proves the integrity of the data you submitted and that you can reproduce it; it does not prove that the underlying real-world facts in that data are true.
  • The item hash supports a submission window, not an original creation time, and says nothing about who authored the data.
  • An item hash alone does not prove inclusion in a block. That requires an inclusion proof over the Merkle tree, and public-blockchain evidence that the block existed. Those are separate steps documented in the verification and merkle concepts.