Open Standard for Deterministic Digital Provenance
Deployed live on Polygon Mainnet. Independently verifiable. MIT licensed.
SHA-256 content hashing at word, paragraph, and chapter level.
Merkle tree commitments per edition with on-chain root anchoring.
Forward-only lifecycle. Zero upgradeability. Client-side verification.
2026 · Polygon Mainnet · Chain ID 137
Direct read-only RPC observation of deployed contracts. No intermediary services.
Chain state could not be read at the edge just now. This is a transport failure, not a change in on-chain state; verify directly on Polygonscan.
0x97f4…8b90
KernelV2 0xca9F…E037
AuthorIdentity 0xB9ff…3170
RoyaltyRouter 0x4416…C461
EditionNFT 0x9e9C…8b0
StoryNFT 0xD67e…7E3
Kernel 0x511c…E8ae
unavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableunavailableProgressive implementation tiers for protocol conformance.
XXXIII reference implementation. 7 verified contracts. Cross-chain anchoring via Polygon + Bitcoin (OpenTimestamps). Client-side on-chain state verification. 293 tests passing.
View Compliance MatrixDrop compiled-manuscript.md
SHA-256 computed locally. Nothing leaves your machine.
Clone. Run. Confirm.
git clone https://github.com/FTHTrading/LPS-1-Reference-Implementation.git
cd LPS-1-Reference-Implementation && npm install
node verifier/cli.js --path example-work
58 checks across 2 suites. All must pass.
This is not trust. This is reproducibility.
Clone · Test · Deploy locally · Verify independently
git clone https://github.com/FTHTrading/LPS-1-Reference-Implementation.git
cd LPS-1-Reference-Implementation
npm install
npm run demo
node verifier/cli.js --path example-work
Six layers. Each independently specified, implementable, and verifiable.
4K desert donkey drama storyboard captures, hyperreal 3D crypto currency models, and cryptographic manuscript plates anchored to Polygon Mainnet.
2,500 donkeys moving through the desert corridor carrying gold bars while paperwork certifies delivery.
Cinematic motion study of the desert crossing under burning sun. The trail thins as attrition rises.
UNREAL / OCTANE 3D MODEL
Hyperreal precision-milled gold coin forged as game-grade 3D engine asset for the Crypto War Room.
3D MODEL · METALLIC LUSTER
Electric gradient reflection with milled edges, representing ultra-fast high-frequency settlement liquidity.
BANK-GRADE INFRASTRUCTURE
Machined circular steel & gold self-governing digital dollar engineered for institutional custodial settlement.
Canonical front cover artwork by Kidd James. Frozen Merkle tree root anchored on Polygon Mainnet.
Each edition is a protocol test vector — a complete, frozen deployment of the LPS-1 standard.
6719ed7f...594edd95d121...67d39c653a2e...2c560e45331c...c63832bed9e5...f32ce57bb947...30fa514c2db5...501e43c24c29...90c6b57afe2a...0151a6c597fc...ab62f5f0358b...df0f3a9e2270...4412de3a8f99...18918f1bca77...1822Six phases from deterministic anchor to multi-implementation adoption.
LPS-1 is designed for multi-implementation adoption. Level 0 requires a single SHA-256 anchor. Level 5 provides full observability.
Select L0 (anchor only) through L5 (fully observable) based on your requirements.
View Compliance Matrix →Fork the public repo. All contracts, tests, and pipeline code are MIT-licensed.
GitHub Repository →Execute the 58-test verification suite against your deployment to confirm determinism.
npx hardhat test
Deploy your own LiteraryAnchor contract to any EVM chain. Minimal Hardhat config included.
npx hardhat run scripts/deploy.js --network polygon
Open a GitHub issue with your deployment address, chain ID, and compliance level achieved.
Submit Statement →LPS-1 satisfies eligibility criteria for public goods funding through:
The reference implementation is production-deployed and independently verifiable today.
Technical specification, architecture, and formal definitions.
This document describes a deterministic literary publishing protocol that establishes cryptographic proof-of-origin, content integrity, and immutable anchoring across decentralized storage and public blockchains.
The protocol formalizes a forward-only edition lifecycle, Merkle-based provenance commitments, and independently verifiable build determinism.
Reference implementation deployed on Polygon Mainnet.
This system does not restrict access.
It proves origin.
Anyone may read.
Anyone may verify.
No intermediary. No trust required. Just math.
SHA-256 canonical hash establishes authorship at byte-level precision.
9d062421b52d35aa23b73bfc8f66574db78bad9726e45c43a12d0109cdd57d84
IV independent Merkle trees combine into a single Edition Root.
6719ed7f9e142a39a4a7db533895562bdf5379cf7f9816ed7cbe045ca359594e
514c2db5b9cd914b96a0a8b50d9dd6981a454c74cab7d717dc38f5fe9fa0501e
IPFS content addressing + Polygon on-chain anchor. Immutable by design.
QmPXtEsRwiWuaKmKNA569XAqFNVySN8pwTdGQrvcdpgtMa
QmVQ79NM3qxAsBpftTG4YhD4KV9sUEmM3WwFrc5vs5g8vK
A five-layer provenance stack. Each layer independently verifiable.
A deterministic sequence from manuscript to chain.
compiled-manuscript.md293,368 bytesSHA-2569d062421...cdd57d84dd95d121...487467d39c653a2e...24202c560e45331c...c56c63832bed9e5...6674f32c6719ed7f...ca359594e514c2db5...9fa0501eQmPXtEsR...cdpgtMaQmVQ79NM...vs5g8vKNo randomness. No mutable state. Reproducible by anyone.
Four independent trees converge into a single edition root.
dd95d121...67d3
9c653a2e...2c56
0e45331c...c638
32bed9e5...f32c
6719ed7f...594e
editionRoot = SHA-256( manuscriptRoot + artifactRoot + imageRoot + promptRoot )
The edition lifecycle is modeled as a monotonic finite-state machine. All transitions are irreversible. All terminal states preserve historical data.
State transitions are irreversible. Data is preserved in all terminal states.
7 contracts deployed. Source verified.
83,010,9444,804,01383,011,55383,110,0652,526,27183,110,1293,059,578Verifiable guarantees that hold at every layer of the protocol.
Identical source files always produce identical SHA-256 hashes. CRLF normalization eliminates platform-dependent line endings. UTF-8 with no BOM. Canonical file ordering via order.json.
Non-upgradeable. Author-only anchoring. Append-only edition history. Frozen editions are permanently sealed. No admin backdoors. Pull-based withdrawals.
Deterministic file ordering. Odd-leaf duplication for balanced Merkle trees. Fixed concatenation order for edition root. No randomness. No mutable state.
Every on-chain record maps to exactly one IPFS CID and one edition root. Every edition root maps to exactly four Merkle roots. Every root maps to a deterministic file hash tree.
Once anchored, no party can alter content without detection. Every byte is hashed and tree-committed.
Block-level timestamps and ECDSA signatures establish authorship with cryptographic certainty.
Prompt logs are Merkle-rooted alongside manuscripts, creating verifiable AI usage records.
Any third party can reconstruct hashes, trees, and roots from source files alone. No platform dependency.
Verification is mathematical, not reputational. The protocol replaces trust with reproducibility.
All content fingerprinting uses SHA-256 (FIPS 180-4). The protocol's integrity guarantees depend on SHA-256's collision resistance. No known practical collision attack exists against SHA-256 as of this writing.
All anchoring and minting operations require the author's private key. Key compromise permits unauthorized anchoring. Key loss is non-recoverable. The trust model is self-self-governing: no recovery mechanism exists by design.
IPFS provides content addressing, not availability guarantees. Content must be actively pinned. CID immutability ensures integrity independent of availability. Loss of all pin providers does not affect on-chain anchor validity.
Client-side chain reads depend on public RPC endpoint honesty. Verification across multiple independent RPC providers mitigates eclipse attacks. All displayed state is independently reproducible via Polygonscan.
No proxy pattern. No admin keys. No governance multisig. Contract behavior is fixed at deployment. This eliminates upgrade-path attacks at the cost of post-deployment mutability. This is an intentional design constraint.
Does not protect accrued royalties from key loss. RoyaltyRouter uses pull-based withdrawals by the author key; if that key is lost, funds already accrued in the router are permanently stranded, in addition to future anchoring being impossible.
Does not prevent copyright disputes. The protocol proves temporal priority of anchoring, not legal ownership.
Does not guarantee IPFS availability. Content addressing ensures integrity but not persistence without active pinning.
Does not prevent private key loss. Self-self-governing identity has no recovery mechanism by design.
Does not enforce content quality. The protocol is agnostic to the literary merit of anchored works.
Does not provide offline verification. On-chain state observation requires network access to an RPC endpoint.
Why deterministic provenance matters, and how to check every claim on this page yourself. Read in place, or open each piece.
Every published text now travels through a dozen hands and programs before a reader sees it. Somewhere on that path a sentence changes, and nobody can say when. When a dispute arrives, the only evidence is a screenshot and a memory.
LPS-1 answers this with a procedure, not a promise. The work is canonicalised so that line endings, invisible marks and file order cannot change its fingerprint. Every file is hashed with SHA-256. The hashes are organised into Merkle trees by content type, and the four roots are combined into one edition root. That root is written to a public chain with a block timestamp and cross-stamped to Bitcoin through OpenTimestamps.
The word that matters is deterministic. Two honest people on two different computers must get the same root from the same files, or the whole idea collapses into argument. The reference implementation ships the normalisation rules and the tests that prove them, and this site reads the anchored roots straight from the chain so you can compare.
What it does not do is just as important. It does not decide who owns a work; it proves who anchored it first and that it has not changed since. It does not keep a file available; it makes any copy checkable. It does not stop copying; it makes plagiarism provable.
The thirty-second way: open the JSON at /api/state. Every value carries the command that produced it. Paste the command into a terminal and you are asking Polygon directly, not us.
The two-minute way: open Polygonscan at any of the seven contract addresses, choose Read Contract, and call editionCount, latest and getIdentity. Polygonscan is independent of this site. If its answers match the page, the page is honest.
The five-minute way: clone FTHTrading/LPS-1-Reference-Implementation, run npm install, then node verifier/cli.js --path example-work. The verifier rebuilds the hashes and Merkle roots from the files and compares them with the chain. On 2026-09-09 the contract suite passed 58 tests and the pipeline suite 21 on our machine; the commands are in the evidence ledger.
There is also a free endpoint: GET /v1/verify/{editionRoot|sha256|cid}. It reads KernelV2.isAnchored and walks the kernel's editions to tell you whether your hash, root or CID is anchored, which edition it belongs to, and when.
The seven LPS-1 contracts are not upgradeable. There is no proxy and no administrator who can swap the code. That is why the rules cannot change after the fact, and why a mistake cannot be patched after the fact either.
Key loss is therefore final. The security section of the standard says so for anchoring: lose the author key and no further editions can be anchored. There is a second consequence that a buyer of an edition token should see. RoyaltyRouter pays out by pull-based withdrawal: funds accrue in the contract until the author key withdraws them. If that key is lost, whatever has accrued is permanently stranded. The router has received and withdrawn 0.01 POL to date and holds a zero balance, so the exposure today is small, and the page now states the consequence in its Limitations.
What the design gives in return is a record nobody can quietly edit, including the people who wrote it. For a provenance standard, that trade is the point.
Publishers are being asked whether a model was involved in a work and how. The usual answer is a line of front matter. LPS-1 gives a better one: when a model is used, the prompts are hashed into their own Merkle tree, and that prompt root is one of the four roots inside the edition root. The edition also records the model name and a hash of the prompt set.
The disclosure becomes a commitment. If someone later claims the prompts were different, or that no model was used, the root will not match. A human-only edition has an empty prompt tree and says so. A model-assisted edition has a prompt tree and says so. Either way, a reader can know, and can check.
This is the same discipline UnyKorn applies to its own reporting: every figure in the annual report family resolves to a ledger row with the command that produced it. A disclosure you cannot check is a sentence. A disclosure you can check is evidence.
Deterministic Literary Publishing:
A Multi-Layer Provenance Model for Verifiable Manuscripts
Working Paper · Published February 15, 2026 · Version 1.0 · Open Access
Independent research. Indexed in OpenAIRE. Reference implementation deployed on Polygon mainnet.
digital provenance · deterministic publishing · Merkle trees · content integrity · reproducible pipelines · literary technology · on-chain anchoring · IPFS · smart contracts · cryptographic verification