Entropy Verification Levels
The two verification levels of a Truestamp entropy observation, recomputing its two stored hashes versus reading the value back from its public source, how both apply to an item proof's witnesses, where the submitted-after edge comes from, and the clock delta between publication and capture.
Overview
Every captured entropy observation carries a stored entropy hash over its captured data, an observation hash (its Merkle leaf), and, once it is committed, a commitment holding the inclusion proof that walks it into its block’s tree. Observations are not signed: the record of the block whose tree holds an observation is. Verification answers two independent questions about that observation, and they form the two verification levels a user sees. Internal verification asks “is this record internally consistent?” by recomputing its hashes, using only the stored record and no network access. External verification asks “does this value actually match what the original public source published?” by re-fetching the value from that source and comparing fields. A combined verification summary merges both, plus the Merkle inclusion check, into one overall pass or fail. The Merkle check is the one that binds the observation into a finalized block, fixing where the observation sits in Truestamp’s own ledger; once that block’s commitment into an epoch exists, and a public blockchain holds the epoch’s hash, the observation is pinned to a public moment it must already have existed before. An observation also does a second job, outside its own page: an item whose record names it as a witness can be shown to have been submitted after the moment that source published the value, the earlier edge of a submission window, once a verifier reads the value back from that source and finds it equal. Each level proves a different thing, so a user should read them together, not in isolation. For what the underlying sources are, see entropy sources.
Internal verification
Internal verification runs every check that needs nothing but the stored observation itself. It does not touch the network, so anyone holding the record can run it offline. It combines two checks, both recomputed from the stored row, and passes only if both pass.
- Entropy hash check (0x20). The observation’s entropy object is rebuilt from the row: its source’s short name, the network the source was read from (NIST has none) and the raw entropy value exactly as captured. The object is canonicalized with JSON Canonicalization Scheme (JCS), hashed with SHA-256 after the entropy byte prefix 0x20, and compared with the stored entropy hash. See domain-separated hashing for why the prefix matters. A match shows the stored hash is the hash of the stored value. What fixes the value is the observation’s leaf in a signed block and that block’s commitment into an epoch on a public chain.
- Observation hash check (0x21). The observation record, the stored entropy hash and the observation’s id, is canonicalized and hashed after the byte 0x21, and compared with the stored observation hash. That hash is the observation’s leaf in its block’s Merkle tree, so a match proves the leaf names exactly this observation and this value. A record that cannot be hashed (an id that is not text, say) fails the check with the reason.
What internal verification proves: the record is self-consistent (the stored hashes really are the hashes of the stored value and id). What it does not prove: that the value genuinely came from the external public source, which external verification adds, or that Truestamp recorded it at a given point in its ledger, which the Merkle check and the signed block add.
External verification
External verification re-fetches the value from the original public source over the network and compares the published fields against what Truestamp stored. It is the level that ties an observation back to the real world outside Truestamp. The comparison is source-specific:
- Bitcoin observation. The block is looked up from public block explorers (with fallback providers) and the block height, hash, and timestamp are compared.
- NIST beacon observation. The pulse URL is reconstructed from the chain and pulse indices, and the chain index, pulse index, output value, and timestamp are compared.
- Stellar observation. The ledger is looked up by sequence number and the sequence, ledger hash, and close time are compared.
What external verification proves: the stored value is a faithful copy of what the named public source actually published, so anyone can independently confirm the same value from that source.
The answer compared against may be one Truestamp retrieved earlier rather than a lookup made for this check. A published pulse, a closed ledger and a deep enough block never change, so Truestamp keeps the source’s answer and reuses it instead of asking the source again on every view. The result always says which source answered and when it was retrieved.
One caveat is worth stating plainly. External verification confirms that the value exists at the source, not that it was fresh at capture. If a source freezes and republishes an old value (for example, the NIST beacon repeating its last pulse during a US government shutdown), external verification still succeeds against that frozen value. It confirms existence, not freshness.
The verification summary
The verification summary is the combined result a user reads to judge an observation overall. It runs all layers and merges them into one report: the two internal hash checks, the Merkle inclusion proof, and the external source check. The overall status passes only when no individual check fails.
The Merkle inclusion check is what binds the observation into a finalized block, fixing its place in Truestamp’s ledger; once a public blockchain holds the hash of an epoch that block is committed into, that same binding pins the observation to a public moment it must already have existed before. It is only meaningful once the observation has been committed into a block, so before that point the summary marks the Merkle step as skipped rather than failed. A skipped step is not a failure: an observation that has been captured but not yet committed can still pass internal and external verification while its Merkle step is pending. Once committed, the Merkle step reads the observation’s commitment row: it first checks that the inclusion proof’s tree size equals the leaf count the block’s record commits (a proof can reach the root under a size other than the tree’s, so the walk alone does not fix the leaf’s position), then that the proof walks from the observation hash to the block’s Merkle root.
Reading the levels together:
- Internal passes, external passes, Merkle skipped. The record is consistent and matches its public source, but it is not yet committed into a block, so it is not yet bound into Truestamp’s ledger.
- Internal passes, external passes, Merkle passes. Full confidence: consistent, matches the source, and committed into a block whose inclusion proof checks out.
- Any check fails. The summary fails overall, and the failing level tells the user which guarantee did not hold.
The same two levels inside an item’s proof
The levels above describe checking a standalone entropy observation on its own page. The identical pair of questions is asked, under the identical two levels, when an observation appears inside another subject’s proof bundle as one of that item’s witnesses.
When you submit, your item’s witness_hashes records one hash per witness: the block then at the head of Truestamp’s ledger, plus the entropy hash of the newest captured observation from each entropy source that had one. The item hash covers witness_hashes with the claims hash and the item’s id, so the choice is fixed at submission and cannot be revised afterwards. Only the entropy witnesses give the submitted-after edge; the head block fixes the item’s place in the ledger and gives no edge. A proof bundle carries each of those observations’ payloads in full, and a verifier then runs:
- The internal level, as a rehash. Canonicalize the carried entropy object, hash it under the same entropy byte prefix, 0x20, and compare the result with the entry your item’s
witness_hashesholds for that source. A match proves the bundle carries exactly the entropy your submission named: the hash it is compared with is inside your item’s hash, which the signed block and its commitment fix. It needs no network access and no Truestamp server. - The external level, as a re-fetch. Read the pulse, ledger, or block back from its own public source and check that it holds the values the carried object holds. The time the edge rests on comes from that read, never from the carried payload: the NIST pulse’s time stamp, the Stellar ledger’s close time, or the median time past of the Bitcoin block. The submitted-after edge is the latest of those times among the witnesses confirmed in that run. A run that confirmed none, an offline run among them, has no submitted-after edge, and its report says why each witness gave none.
One difference from the standalone case is worth noting: the Merkle step answers a different question here, because the inclusion proof in an item’s bundle walks that item into its block, not the observation into its own.
Every proof Truestamp serves of an item carries every witness its record names, so the rehash of each one needs only the file; the re-fetch still reads each witness from its own source.
The existence-not-freshness caveat carries over unchanged, and it is worth restating in this setting: confirming a witness proves the value really was published at that source, so your submission cannot have happened before that moment. It does not prove the value was fresh when captured. A frozen source yields a true but looser edge, never a false one. In the other direction, when the window is established and the time Truestamp recorded in the item’s id falls before the submitted-after edge, the report adds an informational row, recorded_time_outside_window, which changes no verdict: that time is Truestamp’s record, not evidence.
The clock delta: source time versus capture time
Alongside the verification levels, every observation carries a derived timing signal: the clock delta, the difference in whole seconds between the moment the source itself claims for the value and the moment Truestamp captured it. The source-claimed moment is read out of the stored raw value, so it is part of what the data hash protects: the publication timestamp of a NIST beacon pulse, the timestamp in a Bitcoin block header, or the close time of a Stellar ledger. The delta is computed on demand from the stored record rather than stored itself.
Reading the sign:
- Near zero. The source published the value and Truestamp captured it almost simultaneously, the expected shape for live capture.
- Negative. Capture happened after the source’s claimed moment. Small negative values are normal network and processing delay.
- Positive. The source’s claimed moment is ahead of Truestamp’s capture clock. Bitcoin block header timestamps are set by miners and are routinely minutes ahead of wall-clock time, so modest positive deltas are expected for Bitcoin observations.
The product shows the delta as a warning badge only when its magnitude exceeds five minutes: in the entropy lists for every source, and on a block’s page only for observations captured from a live stream, since a polled observation’s delta mostly reflects the polling cadence. The delta never changes any verification outcome: it is not one of the internal or external checks and does not gate the summary. It is a transparency signal that complements the external level’s existence-not-freshness caveat. A small delta is supporting evidence that the observation was captured promptly after the source published the value, while a large one says to look closer at whether the source was frozen, the capture was delayed, or the source’s clock is simply loose.
Limitations
Each level is scoped to a distinct guarantee, so no single level is sufficient on its own.
- Internal verification alone cannot tell you the value came from the real public source; a self-consistent record could in principle contain a value that the source never published. External verification closes that gap.
- External verification alone confirms the value exists at the source but not that it was captured promptly; a frozen or stale source value still matches. It also requires network access to the source at verification time.
- The Merkle inclusion check, and therefore the observation’s binding into Truestamp’s ledger, is only available for observations that have been committed into a finalized block. Until then the summary treats that step as skipped, not failed.