In this browser

Three ways to check

  1. A fingerprint. Paste the salted hash of one read and choose its hour. The server sends the sibling fingerprints, this page hashes its way up and compares with the published seal.
  2. A log entry. In your vault, open Read log, press Verify on a sealed row and then Copy entry. Paste it here. The fingerprint is computed on this page from the entry and its salt; only the fingerprint leaves your browser.
  3. A proof by hand. Paste a root, a fingerprint and the proof lines. Nothing is sent anywhere; the page only does the arithmetic.

Every step of the walk is shown under the result, so you can compare the numbers with your own run of the script below.

The hour the read happened in.

The salted hash of one read. A fingerprint alone says nothing about what was read.

Proof of a real life

A life certificate

A vault can show that it has a long, continuous sealed history without showing anything in it. Open a certificate from its link, or drop the file here.

  1. The signature. The whole certificate is signed by the vault's own signing key, which is made from its vault key.
  2. Each hour. Every listed hour carries a statement, signed by the same key, that the vault was open in that hour.
  3. Each proof. Each statement hashes to a leaf, and its proof leads to the root listed for that hour.
  4. The summary. First and last seal, hours and days with activity and the longest gap are counted again here.
  5. The roots. Each root is compared with the seal this site publishes, and with SigilSeal on chain when the seals are anchored.

What it proves: whoever could open that vault signed in each of those hours, and the site sealed it then. It does not prove who that is, that they are one person, or anything about what is in the vault. While seals are not anchored, the site holds the list of roots.

Signed by a vault

A proof, an agreement, an identity or a pack

Open a proof from its link, or drop any of these files here. The page tells them apart by their first line and checks each in this browser.

  1. A proof of a fact. One claim, signed by the vault's key, with its evidence, and the statement sealed in the hour it was made. Sealed history and team spaces are checked in full here. A single field or an age is the owner's own statement: signed and committed, not checked by anyone else.
  2. A sealed agreement. The text and both parties hash to the fingerprint both vaults signed, and the fingerprint is in the seal of the hour it was signed.
  3. An identity statement. What an owner says about their AI self, signed by the vault and by the self's own key.
  4. A knowledge pack. A public folder signed by its publisher's vault, version by version.

None of these says who a person is. A proof of an age rests on what the owner wrote in their own vault; zero-knowledge proofs, where nobody sees the date and a checker still computes the age, are on the roadmap.

The rules

What a seal is made of

Two hash rules and one line format. The same rules are implemented in the browser, on the server and in the SigilSeal contract, so one proof checks in all three.

  • The salt is 32 random bytes per entry. Without it a fingerprint cannot be linked to a read.
  • Pairs are sorted before hashing, so a proof is just a list of siblings.
  • Leaves and inner nodes use different prefixes, so one can never pass for the other.
Seal rules
leaf  = SHA-256( 0x00 || data )
node  = SHA-256( 0x01 || min(a, b) || max(a, b) )

data  = "sigil-read-v1" \n id \n appId \n kind \n memoryId
        \n count \n at \n salt        (joined with newlines)

An unpaired node at the end of a level moves up unchanged.
The root of an hour is its seal.

With your own code

A complete check in plain Node.js, with no Sigil code in it. Paste your entry into e, set the address, and run it with node verify.mjs.

verify.mjs
import { createHash } from "node:crypto";

const sha = (...parts) => createHash("sha256").update(Buffer.concat(parts)).digest();
const hex = (h) => Buffer.from(h.slice(2), "hex");

// 1. The fingerprint, from the entry you copied out of your read log.
const e = { id: "", appId: "", kind: "read", memoryId: "", count: 1, at: "", salt: "", hour: 0 };
const data = ["sigil-read-v1", e.id, e.appId, e.kind, e.memoryId ?? "", String(e.count), e.at, e.salt].join("\n");
let node = sha(Buffer.from([0]), Buffer.from(data, "utf8"));
const leaf = "0x" + node.toString("hex");

// 2. The proof and the published seal, from the public API.
const site = "https://<your Sigil site>";
const { proof } = await (await fetch(`${site}/api/seals/${e.hour}/proof?leaf=${leaf}`)).json();
const { seal } = await (await fetch(`${site}/api/seals/${e.hour}`)).json();

// 3. Walk up: pairs are sorted before hashing, so no left or right flags are needed.
for (const sibling of proof.map(hex)) {
  const [lo, hi] = Buffer.compare(node, sibling) <= 0 ? [node, sibling] : [sibling, node];
  node = sha(Buffer.from([1]), lo, hi);
}
console.log("0x" + node.toString("hex") === seal.root ? "verified" : "NOT verified");

What a passed check proves

It proves

The entry is in the seal, unchanged

Exactly this entry, with this app, this memory, this count and this time, was part of the hour's seal when it was made. Change one character and the fingerprint no longer leads to the root.

It does not prove

That nothing else happened

A seal cannot show that a server wrote every request down, and while seals are local, Sigil holds the list of roots. Publishing roots on chain closes the second gap and is on the roadmap. Both limits are in the threat model.