What Truestamp Proves
The affirmative guarantees of a Truestamp proof, that the exact bytes existed unchanged and that submission fell inside a submission window a verifier draws from public records the proof names and from the public chain that holds its block's epoch hash, every hash it compares recomputed.
Overview
Truestamp turns a piece of data into a small, self-contained proof that makes two affirmative claims, both checkable by anyone with no trust in Truestamp: the exact bytes of the data existed in that exact form (data integrity), and those bytes were submitted to Truestamp inside a provable submission window. A verifier draws the window’s earlier edge from public records that already existed at submission, which the proof carries and names, and its later edge from the public blockchain that holds the hash of the epoch the data’s block belongs to. Every hash a verifier compares is one it recomputed from the records the proof carries, so no check rests on Truestamp’s word. A proof is one downloadable JSON file signed by Truestamp. If Truestamp is offline or gone, an offline run still confirms the data’s integrity and the recomputed chain from data to epoch hash, and a run given a keyring the holder saved, or a keyless run, still draws the window. A default online run reads Truestamp’s keyring and fails until it answers. Each case is worked through in proof claims by availability.
This concept covers what a proof does establish. What a proof does not establish (original creation time, authorship, or anything about the meaning of the data) is covered in what a proof does not prove.
Data existence and integrity
The strongest and simplest guarantee is integrity: a valid proof shows that a specific sequence of bytes existed, and that not a single byte has changed since.
The mechanism is a hash. Truestamp reduces your data to a 64-character SHA-256 fingerprint. Change one byte of the data and the fingerprint changes completely, so a verifier who re-hashes the same data and gets the same fingerprint knows the data is byte-for-byte identical to what was timestamped. There are two equally valid ways to submit the data behind that fingerprint:
- Hash of an existing file. You compute the fingerprint of a file on your own device and submit only the fingerprint plus a short label. The proof later attests that those exact bytes existed within the submission window. You keep the original file; the proof plus the file together demonstrate integrity.
- The data itself. When the thing you want to attest is the content you are submitting (a written statement, a disclosure, a structured record), you submit that content directly. Truestamp keeps its values exactly as you sent them, in one canonical byte form, hashes that form, and the proof carries it. No separate file is needed; the proof alone reconstitutes the timestamped data.
Both modes produce the same shape of proof and are verified the same way.
From your fingerprint to a single block fingerprint
Your item’s fingerprint does not sit alone. It is combined into a Merkle tree, a structure that folds many fingerprints into one root fingerprint by hashing them together in pairs, level by level, until a single value remains. Each Truestamp block (a page of the ledger, built at least once a minute while there is anything to put in it) has one such root over every item and entropy observation it holds.
A proof includes an inclusion proof: the short list of sibling fingerprints along the path from your leaf up to the root. A verifier starts from the item fingerprint it recomputed, walks that path hashing pair by pair, and must arrive at exactly the root the block’s record names, in a tree of exactly the size the record names. If your data were altered, or your fingerprint swapped for another, the walk would produce a different root and the check would fail. The tree uses distinct prefix bytes for leaves and internal nodes, which prevents an attacker from passing an internal node off as a leaf (see inclusion proofs).
The end result of this layer: the proof binds your exact bytes to one block’s root fingerprint, and any tampering anywhere in the chain breaks the match.
What a proof can attest
Most proofs attest a piece of your data, but a proof is not limited to that. The same proof format and the same verification steps also attest the pieces of Truestamp’s own public ledger. A proof can attest a block (one page of the ledger), a beacon (a block’s fingerprint, republished as a source of verifiable public randomness), or an entropy observation (an outside public randomness value, from the NIST Randomness Beacon, the Stellar ledger, or the Bitcoin blockchain, that Truestamp records into a block). Each of these is verified against the public blockchains in the same way as a data proof.
These subject types are not interchangeable. Every proof names what it attests (data item, block, beacon, or which entropy source), and that type is part of the signed proof. Because the type is covered by the signature, a proof for one kind of subject cannot be passed off as a proof for another: the signature would not check out. The rest of this concept describes the data-item case, but integrity and the submitted-before edge hold the same way for every subject type a proof can attest. A block proof’s subject is the block itself, so it carries no inclusion proof into a block and has no submitted-after edge. A beacon proof carries, for each source with an observation in its block, the latest such observation with its inclusion proof, and those give its submitted-after edge. An entropy proof’s own observation gives its submitted-after edge.
The submission window
Beyond the data’s existence, a proof supports a statement of when it was submitted, expressed as a window with two edges, not a single instant. The verifier draws both edges itself, from public sources it reads, and never from a time the proof carries.
- Submitted after, the earlier edge, rests on the item’s witnesses: records that already existed when you submitted, each named by its hash in the item’s record, which the item’s fingerprint covers, so which records you submitted against is fixed at that moment and cannot be revised afterwards. Three public randomness sources contribute one witness each when Truestamp had captured something from them: the newest value from the NIST Randomness Beacon, from the Stellar ledger, and from the Bitcoin blockchain. Every item proof carries each witness’s record, and a verifier recomputes its hash and compares it with the one the fingerprint committed to, offline. Online, it reads the same record again from NIST, Stellar or Bitcoin, parties Truestamp does not run, and the edge is the latest of the times it confirms that way: a NIST pulse’s time stamp, a Stellar ledger’s close time, or a Bitcoin block’s median time past. The block then at the head of Truestamp’s own ledger is a witness too, but it is minted by Truestamp, so it only fixes where your submission sits in the ledger and gives no edge. A source Truestamp had captured nothing from contributes no witness, which can leave the submitted-after edge earlier, never later.
- Submitted before, the later edge, comes from the public chains. Your item’s block is batched into an epoch for each chain, and each epoch’s hash is written to Stellar or to Bitcoin. The proof carries the walk from your block’s fingerprint into that epoch and the chain’s transaction details; a verifier recomputes them and then reads the chain itself. The edge is the earliest time it reads: the close time of the Stellar ledger that holds the transaction, or the median time past of the Bitcoin block 10 blocks after the one that holds it. The record that closes this edge was written after your submission, on a chain by construction, so no offline run can settle it.
A verifier that reads nothing draws no window: offline it can show the proof is intact and signed, but its best verdict is internally consistent, never verified. Which claims survive Truestamp being offline or gone, a public chain or source being unreachable, or the item being redacted or expired is tabulated in proof claims by availability.
A proof also carries the subject’s identifier, which holds the millisecond time Truestamp recorded at submission. That time is Truestamp’s own record: it never gives an edge, and when a verifier has drawn a window and that time falls outside it, the report says so in an informational row that changes no verdict.
Because Truestamp proves when data was submitted to Truestamp, not when it was originally created, the guarantee is always phrased as a submission window. The fuller mechanics and vocabulary of that window are covered in the submission window.
Independent verification against public blockchains
The window’s submitted-before edge comes from public blockchains that Truestamp
does not control, as its submitted-after edge comes from public sources. Truestamp writes each epoch’s hash onto
its chain in a public transaction (as a Stellar transaction’s hash memo, or as a
Bitcoin output whose script is 0x6a 0x20 followed by the hash’s 32 bytes). Once
it is there, the public chain independently attests that every Truestamp block in that
epoch existed no later than that transaction, and no one, including Truestamp, can
quietly rewrite it.
Every downloadable proof is required to carry at least one such public-chain commitment. A proof with none would rest solely on Truestamp’s own signature, which would mean trusting Truestamp, so the system refuses to generate one until the block has a final commitment on a public chain: on Stellar once Truestamp has recorded the evidence of the transaction, and on Bitcoin once the chain is 10 blocks past the block that holds it. To keep fees bounded, many blocks are committed together: the epoch’s hash covers a Merkle tree over their block fingerprints and the tree’s size, and each commitment in a proof carries the epoch’s record and the inclusion proof that links your block’s fingerprint into that tree.
Verification re-derives all of this from the proof. Every hash a verifier compares is one it recomputed from bytes the proof itself carries; a chain pointer, such as a transaction hash, supports nothing until the verifier reads it.
- It re-hashes your claims and your item’s record, and walks the inclusion proof to the block’s Merkle root.
- It re-derives the block fingerprint from the block’s record, walks each commitment’s inclusion proof to its epoch’s Merkle root, and re-derives the epoch hash.
- It re-hashes each witness record the proof carries and confirms it reproduces the value the fingerprint committed to.
- It checks the signature over the whole proof, and that the signing key is one of Truestamp’s: a verifier online reads Truestamp’s published keyring in each run, and offline uses the one built into it. When the proof carries it, it also checks the ledger block that introduced that key.
- Offline, it checks a Bitcoin commitment’s carried transaction and its txoutproof,
which holds the block header: the transaction’s
OP_RETURNoutput must hold the recomputed epoch hash, and the txoutproof must place the transaction under that header. - Online, it reads each named Stellar transaction and its ledger, and the transaction’s hash memo must equal the recomputed epoch hash. For Bitcoin it confirms that the carried header is the best-chain block at its height, and reads the median time past of the block 10 after it. It also re-fetches each witness from the source that published it. Those reads give the window.
The window’s reads reach the public blockchains and the public randomness sources,
never Truestamp. A verifier that runs offline, or that simply does not want to depend
on any live service, still confirms the entire internal cryptographic chain from data
to epoch hash, witnesses included, but draws no window. The public verification page at
www.truestamp.com/verify renders the full report,
and the command-line client runs the same checks against a
proof file, online unless you pass --offline:
# Verify a downloaded proof, reading the public chains and sources it names.
truestamp verify proof.json
Because a proof carries its signature, its public key, its Merkle proofs, its witness records, and its public-chain transaction references, anyone can rebuild the whole chain of evidence independently. A step-by-step walkthrough lives in verify a proof.
Citations
- RFC 9162: Certificate Transparency Version 2.0. The Merkle tree and the inclusion proofs a proof carries at the block and epoch levels, including the leaf (
0x00) and internal-node (0x01) hashing that backs the data-integrity guarantee.
- Anagram and Cipher Priority Claims
- Blockchain-based Infrastructure for Proof of Existence in eGovernment
- Chronolocation
- Cornerstones, Foundation Deposits, and Time Capsules
- Data integrity
- How The Bitcoin Blockchain Is Fighting Fraud In Guatemala's Presidential Elections
- OpenTimestamps
- Patents and Caveats as Priority Instruments
- Poor Man's Copyright
- Printing a Beacon as a Proof-of-Life Artifact
- Proof Claims by Availability
- Provenance
- Provenance Marks and Registers
- Proving the Integrity of Digital Evidence with Time
- Sealed Deposits with Learned Societies
- Seals, Signets, and Notaries
- Submission Window
- Support and Contact Channels
- The Inventor of Blockchain Would Like a Better Bitcoin
- Timestamp
- Truestamp CLI
- What Truestamp Does Not Prove
- What Truestamp Is
- Witnessed and Notarized Laboratory Notebooks