Knowledge Base
Browse the concepts behind Truestamp. Follow the links between concepts, or search across everything.
Tagged: hash
22
Cryptography
Byte-Prefix Registry
The complete lookup table of every single-byte SHA-256 domain-separation prefix Truestamp uses, the thirteen kinds of SPEC.md 4.3, mapping each byte to what it hashes and whether it is signed, so a verifier can reproduce any hash exactly.
Domain-Separated Hashing (SHA-256 Byte Prefixes)
How Truestamp separates SHA-256 hash contexts with single-byte domain prefixes, keeping leaf hashes, node hashes, and each kind of hashed object in distinct hash spaces to prevent ambiguity and second-preimage confusion.
Ed25519 Signatures
How Truestamp signs exactly three kinds of record with Ed25519 (block records, key handovers, proofs), strict verification, what a proof signature proves, the keyring at /.well-known/keyring.json and which keyring governs each verifier, and the signing key event a proof carries.
Glossary
Block hash
The SHA-256 hash under prefix 0x31 of a Truestamp block's seven-member record (height, id, leaf_count, merkle_root, metadata, previous_block_hash, signing_key_id); it chains blocks, is signed, is a leaf of an epoch tree, is the beacon value, and names each item's block witness.
Byte prefix
The single byte placed before data when Truestamp hashes it with SHA-256 for domain separation; thirteen are assigned, one per construction, from 0x00 and 0x01 for Merkle leaves and nodes through 0x10 claims, 0x31 blocks, 0x40 epochs and 0x50 proofs to the 0x6_ key bytes.
Claims
The user-supplied data map an item is made of - a required name plus optional external content hash and algorithm, description, URL, location, freeform metadata, user timestamp, and nonce, JCS-canonicalized so the claims hash stays independently reproducible by the submitter.
Claims hash
The claims fingerprint, a SHA-256 hash, under the claims byte prefix 0x10, of the JCS-canonicalized claims a user submitted and nothing else; independently reproducible by anyone holding the claims, and bound with the item's id and witness hashes into its item hash.
Data integrity
The affirmative guarantee that the exact bytes submitted to Truestamp remain unchanged - any alteration changes the data's SHA-256 fingerprint and breaks the proof, so a verifier who re-hashes the data detects even a single changed byte; one of the three product pillars.
Domain separation
Truestamp's rule that every record hash, and the Merkle leaf and node, is SHA-256 computed over a reserved single-byte prefix plus the data, so a hash made for one purpose (Merkle leaf, node, item claims, proof hash) can never collide with or be replayed as a hash for another purpose.
Epoch hash
The hash Truestamp writes on a public chain for each epoch - SHA-256 under prefix 0x40 of the epoch record {leaf_count, merkle_root} over the epoch's block hashes - as a Stellar hash memo or a Bitcoin OP_RETURN output; a proof carries it in each commitment entry's epoch.
Item code
An item's short name - 16 uppercase Crockford base32 symbols, the leftmost 75 bits of its item_hash and one check symbol - shown beside the item and accepted in links; anyone can recompute it from a proof, but it is a name, never a proof or a verdict.
Item hash
The hash of an item's record, SHA-256 under prefix 0x11 over the JCS of {claims_hash, id, witness_hashes}; it is the item's Merkle-tree leaf in a Truestamp block, gives the item its item code, is not signed, and leaves out authorship and ownership.
JCS (JSON Canonicalization Scheme)
RFC 8785, the deterministic JSON serialization Truestamp applies to a JSON map (claims, the item, entropy, observation, block, epoch, handover and proof records, and the genesis object) before SHA-256 hashing, so the same data always yields the same bytes and hash, whatever its key order.
Merkle leaf
The bottom-level entry of a Merkle tree, hashed as SHA-256(0x00 || hash) under the reserved leaf prefix so it can never be confused with an interior node (prefix 0x01); block-tree leaves are item and entropy observation hashes, epoch-tree leaves are block hashes.
Merkle root
The single hash at the top of a Merkle tree that commits to every leaf below it; a block record's merkle_root commits to that block's items and entropy observations, and an epoch record's merkle_root and leaf_count hash to the epoch hash recorded on chain.
Merkle tree
A binary hash tree where each parent is the SHA-256 hash of its two children, reducing a whole set of leaves to one root; Truestamp builds these trees over item and entropy observation hashes per block and over block hashes per epoch.
Items
Submit an Item
How to timestamp data by submitting an item on the web form, JSON:API, GraphQL, console WebSocket, CLI, or an MCP agent, with every claims field (name, hash and hash type, description, URL, location, timestamp, metadata), hash mode versus plan-gated claims-only mode, and the limits that apply.
The Item Code
The item code, a 16-character Crockford base32 short name for an item (the leftmost 75 bits of its item_hash and a check symbol), how to check it from a proof, how Truestamp issues, shows and accepts it, how a typed code is read, and what a matching code does not prove.
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.