Proof you built it,
when you said you did.
Git dates can be forged and force-pushes rewrite history silently. Aletheia seals every push to Monad — commit hash, tree hash, block timestamp — into a public timeline anyone can re-verify from a fresh clone. Trust moves from the author to the chain.
One transaction, then a webhook — every push self-attests from that moment. registry 0x80eDe1D4…
Trust on the chain, not the author
Every commit is hashed with its tree and anchored to Monad, creating a permanent record of creation that no force-push can rewrite away.
Three steps, one transaction
Register the repo
Connect a wallet, paste a GitHub URL, sign one transaction. The registry stores keccak256(github.com/owner/repo) and the attestor key. One project per repo, enforced on-chain.
Every push self-seals
A webhook (or a trustless GitHub Action with your own key) turns each push into an Attested event within ~30 seconds — commit hash, tree hash, block timestamp. Force-pushes are marked, never hidden.
Anyone re-verifies
npx aletheia-verify <id> clones fresh, recomputes every commit and tree hash, and diffs them against the chain. Exits non-zero on any mismatch. No keys, no trust in our servers.
A clean-looking history proves nothing
Cheaters can fabricate an honest-looking timeline; honest builders get flagged by guesswork. The record itself has to move somewhere the author can't rewrite.
Author-controlled Git
- closegit commit --date backdates any commit to any moment
- closeA force-push silently rewrites the entire history
- closeTimestamps live in the repo the author fully owns
- closeJudges fall back on fallible fraud-detection heuristics
Chain-anchored Aletheia
- checkBlock timestamps are set by the network, not the pusher
- checkA rewrite still seals at its real time — and is flagged
- checkThe timeline lives on Monad, outside the author's reach
- checkJudges get a verification endpoint instead of guesswork
Every fraud check, answered from the chain
Automated judging asks three questions. Aletheia turns each one from a heuristic guess into a lookup anyone can reproduce.
Did it start in-window?
The first Attested event carries a block timestamp — an offset from the hackathon start no backdated commit can fake.
Is the demo real work?
A commit-by-commit timeline of tree hashes shows the project evolving, not a single dump of placeholder data.
Are the commits suspicious?
Force-pushes are surfaced as rewrite markers on the timeline. Nothing is hidden; the record shows exactly what happened.
Recent proofs
Live stream of registered repositories, straight from the chain.
Questions worth asking
Aletheia claims exactly what the chain can back — and nothing more.
Does this prove I wrote the code?add
No. Aletheia proves timing and continuity — when a repository existed and how it evolved — not authorship or originality. We say so in the UI and the README rather than overstate it.
What happens if I force-push?add
The rewrite is sealed at its real block time and marked on the timeline as a rewrite. Nothing is hidden — a reviewer sees exactly that history was rewritten and when.
Do I have to trust Aletheia's servers?add
No. The record lives on Monad, and npx aletheia-verify re-derives every commit and tree hash from a fresh clone, comparing against on-chain events with nothing but Node and git.
What if the webhook bridge is down?add
A published GitHub Action lets a project attest its own pushes with its own key, bypassing the bridge entirely. The trustless path never depends on our infrastructure.
Can I attest commits from before I registered?add
By design, no. Aletheia only ever attests the present — the push happening now. Back-dating attestations would reintroduce exactly the forgery it exists to prevent.
Which chain, and what does it cost?add
Monad Testnet (chain 10143). Registration is a single transaction; each push is one attestation. No token, no payment.