The problem with traditional proof of authorship is that it depends entirely on trusting the institution that holds the record. Google says you created this document on this date. Microsoft says this file was last modified Thursday. A publisher says the manuscript was received in January. All of these records are modifiable — by the institution, by an administrator, by someone with sufficient access. None of them are cryptographically sealed.
In most circumstances, this doesn't matter. Copyright disputes are rare. Publishers don't tamper with submission dates. Google doesn't retroactively alter your document history. But "usually fine" is not a proof standard, and in the era of AI-generated text — where a machine can produce a 75,000-word novel in under an hour and timestamp the output with any date you choose — "usually fine" is exactly the standard that is being exploited.
What Blockchain Actually Does
A blockchain is a ledger of records — transactions, commitments, data — where each new entry is mathematically linked to the previous one. To alter a past record, you would have to recompute every subsequent record in the chain, simultaneously, faster than the rest of the network is adding new records. In practice, on a network like Polygon with thousands of validating nodes, this is computationally impossible. Past records are therefore immutable.
This immutability is what authorship provenance needs. When you anchor a document on a blockchain, you are not storing the document on-chain — documents are too large for that. Instead, you store a fingerprint: a fixed-length string that is computed from the document's content using a cryptographic hash function.
What Is a Hash?
A hash is the output of a mathematical function that takes any input — a word, a paragraph, an entire novel — and produces a fixed-length output that looks like: a3f2d9c45b1e78.... Two important properties make this useful:
1. Deterministic: The same input always produces the same output. If I hash the sentence "The deal is always about to close" with SHA-256 today, and you hash the same sentence with SHA-256 tomorrow, we get the same hash. This means the hash is portable — I can tell you the hash and you can verify the document without me sending you the document.
2. One-way and collision-resistant: You cannot reverse a hash to reconstruct the original text, and it is computationally infeasible to produce the same hash from different text. Change one letter in the input, and the entire hash changes unpredictably. This means the hash is tamper-evident — if the document is altered after anchoring, the hash no longer matches.
The LPS-1 Anchoring Process
For The 2,500 Donkeys, the anchoring process under LPS-1 works like this:
Step 01
Hash each paragraph
Every paragraph in the manuscript is individually hashed with SHA-256. A 75,000-word novel produces hundreds of individual hashes — one for each atomic unit of text.
Step 02
Build a Merkle tree
The paragraph hashes are assembled into a Merkle tree — a data structure where each node is the hash of its children. The tree produces a single root hash (the "Merkle root") that represents the entire manuscript. Change any paragraph, and the Merkle root changes. The tree structure also allows proving that a single paragraph is part of the manuscript without revealing the entire manuscript.
Step 03
Anchor on Polygon Mainnet
The Merkle root is submitted to a smart contract on Polygon Mainnet via a standard transaction. The blockchain records the root, the submitting address, and the block timestamp. This record is now permanent and publicly verifiable. The block height and transaction hash are the anchoring coordinates.
Step 04
Cross-timestamp on Bitcoin
As an additional layer, the Polygon transaction hash is submitted to OpenTimestamps, which creates a Bitcoin-anchored timestamp. This provides cross-chain verification and independent corroboration of the anchoring moment.
Step 05
Pin to IPFS
The full manuscript, with its anchoring manifest, is pinned to IPFS — a content-addressed storage network where the content hash is also the address. The content cannot change without the address changing, making the IPFS pin both a backup and an additional provenance layer.
What This Proves
After anchoring, anyone can independently verify: (1) that the text of the manuscript hasn't changed since anchoring, by recomputing the hash and comparing it to the on-chain record; (2) that the anchoring happened at a specific block height — a publicly auditable moment in time that cannot be backdated; and (3) that the anchoring address corresponds to the author's public key, providing a chain of identity that connects the anchoring entity to the work.
The verification requires no trust. No API calls to a proprietary service. No account. You clone the repository, run the verifier script, and compare the output to the on-chain record. The LPS-1 verifier implements 58 checks across two test suites. All 293 tests pass on the current version of The 2,500 Donkeys.
What This Doesn't Prove
Blockchain anchoring proves that a specific text existed at a specific time and has not been altered since. It does not prove that the anchoring entity is a human being. It does not prove that the text is original, or non-plagiarized, or written without AI assistance. It does not prove the author's legal identity — the anchoring is pseudonymous at the smart-contract level, linked to a public key address.
These are not weaknesses of the system. They are boundaries. LPS-1 is a provenance standard, not an originality standard. It answers the question "Has this text been altered since this date?" — which is the question that matters most in authorship disputes — rather than the unanswerable question "Was this text written without assistance?"
Why Right Now
In February 2026, a person with a laptop and access to a contemporary language model could produce a novel-length manuscript in an afternoon and timestamp the output on Google Docs to any date in the previous decade. That is a provenance crisis. Not a crisis of creativity — the output might be excellent. A crisis of verifiability. How does anyone know when the text was created, or by whom, or whether the version being claimed as authoritative is the same version that was created?
Blockchain anchoring does not solve the AI-generation problem. Nothing solves that problem. It solves the provenance problem by creating a record that cannot be backdated and cannot be altered after the fact. If you anchor your manuscript today, the record of today will exist permanently, and no one — including you — can construct a record saying the manuscript was anchored in 2023.
That permanence is simple, boring, and extremely powerful. It is the same thing a notary does when they stamp a document with a date. Blockchain does it without the notary, without the trust in the notary's institution, and without any mechanism for the date to be modified after the fact. The chain is the notary. The chain does not lie, because lying would require rewriting all subsequent history.
The deal chain runs on documents no one can verify. The manuscript doesn't have to.