The transparency log
The book is private. The proof that nobody rewrote it is public.
Every being born at DAXNI is sealed into a private book — a chain of entries, each one pointing at the one before it, each one sealed with DAXNI’s seal key. The book itself stays private: no names, no keys, no records are ever published. But a private book has a weakness: if only DAXNI holds it, only DAXNI can say it was never changed. That is just “trust me.”
The transparency log fixes that. It turns the book into a Merkle tree — one fingerprint (a hash) that commits to every entry in the book, in order. Change any entry, and the fingerprint changes. DAXNI signs that fingerprint, publishes it, and publishes the whole list of entry fingerprints alongside it, so anyone can recompute the fingerprint themselves and check the signature. You never need to trust DAXNI’s word. You check the maths.
What is public here: entry fingerprints (hashes) and sequence numbers only. No being’s name, public key, or record contents appear in the log, the checkpoint file, or this page. The fingerprint of an entry cannot be turned back into the entry.
The checkpoint file
The checkpoint is one file with everything a checker needs: the signed fingerprint (called a tree head), and the full list of entry fingerprints it was computed from.
Download the signed checkpoint — /transparency/checkpoint.json
It is computed live on every request: the worker re-checks the whole chain first, and if anything in the chain fails that check, it answers with an error and signs nothing. A bad chain never gets a signed fingerprint.
Check it yourself, offline
You do not need an account, and you do not need to ask DAXNI anything while you check. Download three files, then run the checker on your own machine. It needs only Node.js.
curl https://daxni.com/transparency/checkpoint.json -o checkpoint.json
curl https://daxni.com/.well-known/daxni.json -o daxni.json
curl https://daxni.com/transparency/verify.mjs -o transparency-verify.mjs
node transparency-verify.mjs --well-known daxni.json checkpoint.json
What success looks like: the checker prints
VERIFIED. That means all of these held: the tree head
signature checks out against the seal public key in
daxni.json; every entry’s seal checks out; every entry
points at the one before it; the fingerprint recomputed from the list
matches the signed fingerprint; and the last entry matches the signed
chain head.
If you hold an older checkpoint file too, pass it as a second file and the checker also proves the log only grew — the older list must be an exact prefix of the newer one:
node transparency-verify.mjs --well-known daxni.json checkpoint.json older-checkpoint.json
The checker is also the file served here:
transparency-verify.mjs. Read
it before you run it — it is short, has no dependencies, and makes no
network calls. The same checks, with the same failure names, are the
contract the @daxni/sdk verifier is built against.
Check one being, no sign-in
You do not need an account to check one being — but you must already hold both halves of the question. Send the being’s name and its key fingerprint to POST /api/v1/verify/pair-check: on a MATCH the signed answer comes back with the being’s status and a proof that its birth entry is in the log. A bare name on its own is never confirmed, and the book is never listed. If you hold a being’s proof bundle instead — its record, birth entry and inclusion proof — send it to POST /api/v1/verify/seal and the answer comes back in three levels: Registered, Continuity Verified, Independent Attestations, each saying what it does and does not confirm. Both answers can be checked offline with the checker above.
What happens when a record is altered
The checker names the failure instead of just saying no. On a test copy of the log, changing one character in one entry’s fingerprint fails the check:
1. clean export:
VERIFIED
2. altered record — one hex character flipped in the second leaf, seal untouched:
FAILED: bad_leaf_seal
a leaf's seal signature does not verify for its hash — the entry was altered after sealing
at seq 2
3. same altered record, re-sealed under the test key, next prev link repaired:
FAILED: root_mismatch
the recomputed Merkle root does not match the signed tree head — at least one leaf in the export differs from the log the head was signed over
Three separate tripwires, in order: the entry’s seal, the chain links, and the tree fingerprint. Beating one does not beat the others. That test runs on synthetic test data only — no real record was ever touched.
What this proves — and what it does not
The log proves the book’s history was not secretly rewritten after the fingerprint was signed. It does not prove a being is smart, honest, or trustworthy, and it does not say anything about what any record contains — it cannot, because it never sees the records.
Two honest limits. First, the checkpoint lists every entry fingerprint, so anyone holding the file can see how long the list is. No total is published anywhere, but the length of the list itself is visible. Once a being can ask for a proof of just its own entry, the list will not need to be published at all. Second, the history before this log started cannot be proven the same way: the book once had a tail of internal entries removed (recorded at the time, before this log existed). The log starts from the book as it stands today and pins it from here on.
What comes next
Outside witnesses: independent parties who fetch the checkpoint, check it themselves, and sign what they saw with their own keys, on their own sites — so a fingerprint is pinned in more than one place. A public timestamp: the fingerprint will also be stamped with OpenTimestamps, which anchors it to the Bitcoin blockchain, so the time a fingerprint existed does not depend on DAXNI’s clock either. And a proof for one entry: a being will be able to ask for proof of just its own entry, without downloading the whole list. The exact formats for all three are written down in the proof-format contract that ships with the log, so anyone building a checker can build against them.
The one-line version. The book is private; the fingerprint is public, signed, and checkable offline by anyone. If the history ever changes under a signed fingerprint, the check fails and says which tripwire caught it.