Knowledge Base

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

Submission Window

The submission window is the time guarantee of a Truestamp proof, that data was submitted after public records it witnesses and before a public chain recorded its block's epoch hash, each edge drawn by a verifier from public reads, which is why we say submitted rather than created.

Overview

The submission window is Truestamp’s core time guarantee: a proof that a specific piece of data was submitted to Truestamp between two edges a verifier draws from public records. It is a claim about submission timing, not creation timing. Truestamp can prove that your data was submitted after one point in time and before another, but it cannot prove when the data was first created or how long it existed before you submitted it. This is why the product always uses the words “submitted” and “submission window” and never “created” or “creation time” for this guarantee.

The earlier edge of the window rests on public records that already existed when you submitted, and the later edge on the public blockchain transaction that recorded the hash of the epoch your item’s block belongs to. Each is fixed by a hash: the earlier records are named in the item’s own fingerprint at submission, that fingerprint is a leaf of its block’s Merkle tree, and the block’s fingerprint is a leaf of the epoch’s tree. Neither can be altered after the fact without breaking the proof, and a downloaded proof carries the evidence for both. A verifier draws each edge from its own reads of the public sources and chains, never from a time the proof carries. The next section says exactly how each one is fixed.

How the window is bounded

Every item carries a submission window with two ends.

  • Submitted after (the earlier edge). At the moment you submit an item, Truestamp records a hash for each of its witnesses: the block then at the head of the ledger, and the newest observation captured from each public entropy source that had one, from the NIST Randomness Beacon, from the Stellar ledger, and from the Bitcoin blockchain. Those hashes are members of the item’s record, which the item hash covers, so which records your submission was made against is fixed and cannot be changed later without breaking the proof. A verifier reads each entropy record again from its source and takes that source’s time: a NIST pulse’s time stamp, a Stellar ledger’s close time, or a Bitcoin block’s median time past. The latest of the times it confirms is the edge: your data was submitted after that public moment.
  • Submitted before (the later edge). Shortly after submission, the item’s hash becomes a leaf of a new block’s Merkle tree, and the block is finalized. On Truestamp’s own ledger that shows the item was submitted before the block was finalized. The block is then batched into an epoch for each chain, and each epoch’s hash is written to Stellar or to Bitcoin. For Stellar, a verifier reads the transaction and its ledger, checks that the transaction’s hash memo equals the epoch hash it recomputed, and takes the ledger’s close time. For Bitcoin, it checks offline the transaction and the txoutproof the proof carries, the txoutproof holding the block header: the transaction’s OP_RETURN output must hold the epoch hash it recomputed, and the txoutproof must place the transaction under that header. Online, it confirms that this header is the best-chain block at its height and takes the median time past of the block 10 after it. The earliest of those it reads is the edge: your data was submitted before that public moment.

Together the two edges pin the submission to the interval between them. A block-creation run is scheduled at every minute boundary, and a block is created then whenever there is at least one leaf to include, whether an item or an entropy observation; empty blocks are never created. Extra blocks are also built, as often as every ten seconds, while at least 1,000 items and observations are waiting, so an item’s block is usually finalized within a minute of submission. Stellar epochs go out every five minutes, so the submitted-before edge read from Stellar usually falls within minutes of submission; read from Bitcoin it usually falls one to two hours after: the wait for the block’s Bitcoin epoch, then the median time past of the Bitcoin block 10 past the one that holds the epoch’s transaction. The earlier edge is usually close to submission: Stellar closes a ledger every few seconds and NIST publishes about once a minute, so the newest captured observation is normally seconds old when you submit.

The head block is a witness too, but a different kind. It is minted by Truestamp rather than published by an outside party, so it fixes where your submission sits in Truestamp’s own chain, and it gives no edge: no public source holds its time.

The epoch hash is written to public blockchains (Stellar and Bitcoin), and the entropy records were published by parties Truestamp does not control, so both edges of your submission window rest on times Truestamp can neither set nor backdate. The mechanics of proving that an item is a leaf of its block’s Merkle tree ride inside the item’s proof.

What a proof bundle establishes on its own

A proof bundle carries evidence for both edges, and the two are established in different ways.

  • The submitted-before edge is a pointer the chain confirms. The bundle carries the inclusion proof up to the block’s Merkle root, the block’s record, and at least one final public-chain commitment of that block: the epoch’s record and the walk from the block’s fingerprint into the epoch’s tree, with the chain’s transaction details. A verifier recomputes all of it with no help from anyone, and then reads the public chain, which is the external grounding: the Stellar transaction and its ledger, or the best-chain Bitcoin block at the carried header’s height and the block 10 after it. It cannot be settled offline, because the record that closes it is written after your submission and lives on a chain by construction.
  • The submitted-after edge rests on records the bundle carries outright. The witness hashes are the item’s witness_hashes, which its item hash covers with the claims hash and the item’s id, and every item proof also carries the records themselves: the head block’s node and each entropy source’s captured object. A verifier rehashes each one and confirms it reproduces the value the fingerprint committed to, offline, and then reads the same record again from NIST, Stellar, or Bitcoin to confirm it really is what that source published. Only that second step needs a network, and none of it needs Truestamp. The edge such a verifier reports is the latest time it confirmed from those sources.

Every item proof carries the record of each witness its witness_hashes names; there is no choice of witnesses to make. The one choice made when a proof is generated is the constructions argument, which says whether the proof carries the constructions text in full, names it by reference, or leaves it out, and it changes nothing about which witness records ride along. A record that did not hash to the value the item hash covers would be rejected.

The subject’s id holds the millisecond time Truestamp recorded when it minted the id. That time is Truestamp’s own record, never an edge. When a verifier has drawn a window and that time falls outside it, the report adds an informational row saying so, which changes no verdict. The verifier does check, offline, that the head block the item names sits lower in the ledger than the block that includes it.

What each edge survives when Truestamp is offline or gone, when a chain or an entropy source is unreachable, or when the item has been redacted or has expired is worked through scenario by scenario in proof claims by availability.

What the window claims

The submission window claims only what a hash and the public records a verifier reads can support.

  • Submitting a hash proves the data exists. You cannot produce a matching hash without possessing the data, so a proof establishes that the data existed in exactly that form (data integrity and existence).
  • The window proves when it was submitted, not when it was created. The data may have existed for seconds, years, or centuries before you submitted it. Submitting a passage of Shakespeare proves the text exists and that you submitted it inside the window, but says nothing about when it was written.
  • There is no lower bound on creation. Truestamp cannot prove that data was not created earlier. If you hold a document for a year and then submit it, the proof shows only that it existed by the time you submitted, not a year ago.
  • The submitted-before edge is an “existed by” guarantee. Because the data’s block was finalized before its epoch hash was written to a public blockchain, the data provably existed no later than that public commitment.

A proof makes no claim about creation time. Without a trusted-time oracle, cryptography alone cannot prove when data was created, so a proof asserts only the window in which it was submitted.

Why we say “submitted”, not “created”

The vocabulary is load-bearing. “Submitted” and “submission window” describe exactly what a proof shows, from its hashes and the public records a verifier reads; “created” and “creation time” describe a stronger claim that nothing in a proof can back.

Correct phrasings:

  • “Proof that data was submitted between public value X and public transaction Y”
  • “Data was submitted after public value X was published”
  • “Data was submitted before the Stellar ledger (or Bitcoin block) that recorded its block’s epoch”
  • “Proof that the data existed by the time of the submitted-before edge”
  • “Proof of submission window”

Phrasings to avoid, because they overstate the guarantee:

  • “Proof that data was created at time X”
  • “Proof of when the data was created”
  • “The data could not have existed before this block”

For the wider set of things Truestamp does and does not prove, see what Truestamp proves.

Limitations

  • Truestamp cannot prove when data was first created, only that it existed by the time of the submitted-before edge.
  • Truestamp cannot prove how long the data existed before submission, or that it was not created much earlier.
  • Truestamp does not prove original authorship. It records who submitted an item, which is not the same as who authored the underlying data. Anyone in possession of data can submit it.
  • Truestamp does not attest to any property of the data beyond the bytes themselves, such as truthfulness, relevance, or legal status.
Referenced by