Data Integrity
Every article ingested by Sarchy is cryptographically sealed into an append-only blockchain. This makes it possible to prove that content has not been altered, deleted, or reordered after the fact.
Why Blockchain for Source Data?
News content changes. Articles are edited, retracted, or quietly updated. Source attributions shift. When you're building a historical archive, you need a way to prove what was collected and when — without relying on trust alone.
Tamper Evidence
If any article's content is modified after ingestion, the hash chain breaks. Verification immediately reveals which block was altered and when the integrity was compromised.
Temporal Proof
Each block records exactly when content was ingested. Anchor records create point-in-time attestations, letting you prove that a specific article existed in the archive at a specific moment.
Source Attribution
Citations, quotes, and source entities are sealed alongside the articles that reference them. This creates an auditable record of who said what — and when it was captured.
Independent Verification
Anyone with access to the data can recompute every hash from the raw content upward. Verification doesn't depend on trusting the platform — the math is open and deterministic.
How It Works
Every article passes through three cryptographic stages before it becomes part of the permanent archive.
Leaf Hashing
Each piece of content (title + body) is hashed with SHA-512 to produce a unique 128-character fingerprint. This is the leaf of the Merkle tree.
SHA-512(title || body) → leaf hash Merkle Tree Construction
Leaf hashes are paired bottom-up into a binary tree. Each parent node hashes its two children together, producing a single Merkle root that represents the entire article.
SHA-512(left || right) → parent hash Block Chaining
The Merkle root is chained to the previous block's hash, forming an append-only ledger. Altering any past content invalidates the chain from that point forward.
SHA-512(prev_block_hash || merkle_root) → block hash Merkle Trees
A Merkle tree lets you verify any single piece of content without checking the entire archive.
┌──────────┐
│ Root │ ← Merkle Root (stored in block)
│ Hash │
└────┬─────┘
┌─────────┴─────────┐
┌────┴─────┐ ┌────┴─────┐
│ Hash(AB) │ │ Hash(CD) │ ← Inner nodes
└────┬─────┘ └────┬─────┘
┌─────┴─────┐ ┌─────┴─────┐
┌───┴───┐ ┌────┴──┐ ┌┴──────┐ ┌───┴───┐
│Leaf A │ │Leaf B │ │Leaf C │ │Leaf D │ ← Content hashes
└───────┘ └───────┘ └───────┘ └───────┘
Each leaf is a SHA-512 hash of one content section. Leaves are paired and hashed upward until a single root remains. Changing any leaf changes the root — making tampering immediately detectable.
To verify a single leaf, you only need the proof path: the sibling hash at each level from the leaf to the root. This is logarithmic in the number of leaves — efficient even for large documents.
The Blockchain
Blocks form an append-only chain where each block's hash depends on the previous block.
Modifying a block's content changes its Merkle root, which changes its block hash, which breaks every subsequent block in the chain. The further back the tampering, the more blocks become invalid.
Anchor Records
Anchors are point-in-time attestations that snapshot a block's Merkle root.
What They Do
An anchor captures the Merkle root hash and timestamp for a specific block. This creates an immutable checkpoint: you can later verify that all content between two anchors remains intact.
Range Verification
Instead of verifying the entire chain, you can verify just the blocks between two anchors. This is useful for auditing a specific time window — for example, everything ingested last week.
Verification
Three levels of verification are available, from individual content to the full chain.
Proof Path
Verify a single piece of content belongs to a specific block. The proof path provides the sibling hash at each tree level — recompute upward to confirm the Merkle root matches.
Block Verification
Recompute a block's Merkle root from its leaves and confirm the block hash matches the chain. Checks leaf count, hash validity, and sequence integrity.
Full Chain Verification
Verify every block from genesis to head (or between two anchors). Every Merkle root is recomputed from raw content, and every block hash is recomputed from its predecessor.
What This Means for You
Every article you read on Sarchy has a cryptographic proof that it hasn't been altered since ingestion.
Source citations and attributions are permanently recorded alongside the content that references them.
You don't need to trust the platform — the verification is open, deterministic, and independently reproducible.
Anchor records let you audit any time window without scanning the full archive.