External Entropy Sources
How Truestamp captures public entropy from the NIST Randomness Beacon, the Stellar ledger and the Bitcoin blockchain, hashes each observation into a block's Merkle tree and names each source's newest observation as an item's witness, which, read back from its source, gives the submitted-after edge.
Overview
Entropy is unpredictable, public randomness that nobody can know in advance. Truestamp captures it on a best-effort basis from three independent public sources: the NIST Randomness Beacon, the Stellar ledger, and the Bitcoin blockchain. Each captured value becomes an entropy observation, and each observation is used twice. It becomes a leaf of the Merkle tree of the next Truestamp block, beside the items submitted in the same interval, so that block’s hash could not be computed before the value existed. And at the moment you submit, the newest observation of each source is named as a witness in your item’s own record, so a verifier can confirm that your item was submitted after the source published that value. Because these values could not have been guessed before the public events that produced them, they are timing evidence a verifier checks for itself rather than a claim it has to trust.
Why unpredictable public entropy matters
The timing guarantee Truestamp offers is a submission window: an instant your data was submitted after, and an instant it was submitted before. Public entropy is what gives the earlier of the two, the submitted-after edge.
The key property of a good entropy source is unpredictability. You cannot know tomorrow’s Bitcoin block hash or NIST beacon value today, and once a value is published it is part of a widely replicated public record that anyone can look up. So a record that depends on a value that only came into existence at a certain time cannot have been made any earlier: it could not have been precomputed, because the entropy it depends on did not yet exist. An item gets that claim from the entropy its own record names, which is fixed when you submit rather than when its block is built.
This is a proof of submission, not of creation or authorship. Naming a fresh entropy value in your item’s record shows you submitted the data after the value was published, once a verifier reads that value back from its source and finds it equal. It does not prove who created the data or when it was originally written. For more on that distinction, see the submission window.
Public sources are chosen because they are hard to corrupt or forge:
- No single publisher you have to trust: these beacons and blockchains are widely replicated.
- Values are cryptographically chained or signed at the source.
- Anyone in the world can independently look up the same value.
- Guessing a future value in advance is computationally infeasible.
The three sources
Truestamp captures entropy from three independent public sources. Each one has its own capture mechanism and its own switch, so a problem at one source never blocks the others.
NIST Randomness Beacon
The NIST Randomness Beacon is a public service run by the US National Institute of Standards and Technology that publishes a fresh, cryptographically signed random value once a minute, each one linked to the previous in a tamper-evident chain. Truestamp polls the beacon over HTTP every ten seconds and captures each new pulse once, storing five of its fields: the random output value, the chain and pulse indices, the pulse’s time stamp, and its version. That is enough to look the pulse back up in NIST’s public records. A pulse the poller missed is never filled in later.
Stellar ledger
The Stellar network closes a new ledger every few seconds, and each closed ledger carries a hash agreed by distributed consensus. Truestamp subscribes to a live stream of these ledgers and captures each ledger’s sequence number, its hash, and the time it closed, together with the network it was read from. The ledger hash is a consensus output that no single party controls, which makes it a good unpredictable public value.
Bitcoin blockchain
Bitcoin produces a new block roughly every ten minutes, and each block hash is the output of an enormous amount of proof-of-work that cannot be predicted ahead of time. Truestamp captures new Bitcoin blocks, from a live stream and by polling, and stores each block’s hash, its height, and the time in its header, together with the network it was read from.
How a captured value joins a block
Every captured value becomes an entropy observation, which keeps the captured fields exactly as the source published them. Two hashes are computed from it, and anyone holding the same values can recompute both:
- its entropy hash, SHA-256 under the byte
0x20of the JCS form of its entropy object: the source’s short name, the captured fields, and, for Stellar and Bitcoin, the network; - its observation hash, SHA-256 under the byte
0x21of the JCS form of{entropy_hash, id}, which is its leaf in a block’s Merkle tree.
The byte prefixes are listed in the byte-prefix registry. An observation is not signed. Its observation hash becomes a leaf of the Merkle tree of the next block Truestamp builds, directly beside the item hashes of the items submitted in the same interval: one tree covers both. The block’s record, which is signed, holds that tree’s root and leaf count, and the observation’s commitment into the block holds the inclusion proof that walks its observation hash to that root.
An observation moves through three states: created when it is captured, processing once it is assigned to a block, and committed once its commitment into that block exists. Entropy is public data: there is no private or tenant-scoped entropy, and every observation can be browsed on the public entropy pages without an account.
How a captured value enters your item
Joining a block is one of two independent routes entropy takes into a proof, and the second one binds to your submission rather than to the block around it.
At the moment you submit, Truestamp reads the newest captured observation of each source and puts its entropy hash in your item’s witness_hashes, beside the hash of the block then at the head of the ledger. witness_hashes is a member of the item’s record, which the item hash covers, so which witnesses an item names is fixed at submission and cannot be revised afterwards.
The two routes give a verifier different things:
- As a Merkle leaf, an observation, once read back from its source, shows that its block was built after the value was published. A beacon proof carries, for each source, the observation of its block with the latest source time, and those observations, each read back from its source, are where a beacon’s submitted-after edge comes from. A block proof has no submitted-after edge.
- As a witness, an observation shows that your item specifically was submitted after the value was published. Every proof of an item carries the entropy object of each witness it names. A verifier rehashes it and compares the result with the entry in
witness_hashes, then reads the pulse, ledger, or block back from its public source and checks that it holds the same values. The time that read gives, the NIST pulse’s time stamp, the Stellar ledger’s close time, or the median time past of the Bitcoin block, is that witness’s candidate, and the submitted-after edge is the latest candidate among the witnesses confirmed. Neither step asks Truestamp anything.
A source that had captured nothing at the moment you submitted contributes no witness. Naming fewer sources can leave the submitted-after edge earlier, never later, so entropy availability never blocks or delays a submission. Every proof of an item carries every witness its record names: no variant of a proof leaves a witness out.
Why this strengthens the guarantee
A record cannot have been made before the entropy it depends on existed. That single fact is what public entropy adds to a Truestamp proof.
Without entropy, the window would have no earlier edge a stranger can confirm. With it, an item is bound to concrete public events that already existed when it was submitted, and anyone verifying its proof can read the referenced NIST pulse, Stellar ledger, or Bitcoin block from its public source, confirm the captured value is real, and conclude that the data was submitted after that time. Capturing from three independent sources means the edge does not rest on any one operator or network staying honest and available: the submitted-after edge is the latest time among the witnesses a run confirmed, so one frozen or unreachable source costs precision rather than the edge itself, unless it was the only one confirmed.
The three sources are not interchangeable at both edges. All three can give the submitted-after edge, read back from the source, since each publishes a value that could not have been known earlier. Only Stellar and Bitcoin give the submitted-before edge, because that edge needs an outside record made after the block existed, and it is to Stellar and Bitcoin that Truestamp writes its epoch hashes, each fixing a batch of block hashes. A chain record of that kind is not a witness: it is made after your submission rather than published before it. Nothing is ever written to the NIST Beacon, so NIST speaks only to the earlier edge.
What can be confirmed about a single observation, from recomputing its hashes offline to reading the value back from its source, is covered in entropy verification levels.
Limitations
Public entropy proves submission timing, not creation or authorship. It shows that data was submitted after a captured value existed; it says nothing about when the data was originally created or who wrote it.
The guarantee is also only as fresh as the source. If a public source temporarily stops publishing new values, for example the NIST beacon repeating its last pulse during a US government shutdown, a verifier can still confirm that the captured value exists in the source’s records, but that value no longer pins the moment down as tightly. Existence remains verifiable; freshness may not, until the source resumes.
- Beacon
- Bitcoin
- Entropy observation
- Entropy source
- Entropy Verification Levels
- Interoperable Randomness Beacons (NIST CSRC)
- NIST Randomness Beacon
- Public Entropy Beacons
- Public Ledger Explorer
- Public Randomness Beacons
- Stellar
- Stellar Developer Documentation
- Time Page
- Truestamp's Merkle Tree
- Verification level
- Witness