Developers

Implement and verify the Human Seal

Built entirely on proven standards: Ed25519 signatures (RFC 8032), sha256 content binding (FIPS 180-4), and the W3C did:web trust root. Nothing here is a new cryptographic primitive.

The receipt

A Human Seal is a small JSON object. The fields below are signed; personal data never appears (the approver is a stable reference, never a name or email).

Field	Meaning
`action_id`	Stable identifier of the approved action.
`action_type`	The class of action (used for the authority check).
`content_hash`	`sha256:` of the exact canonical action. Binds the Seal to that action.
`tenant`	The organization whose model the approval was checked against.
`approver_ref`	Stable identity reference of the approver. Never personal data.
`decision`	`approved` or `refused`.
`decided_at`	UTC timestamp (ISO 8601).
`issuer`	The did:web trust root, e.g. `did:web:humanseal.world`.
`level`	The assurance level (2 = Signed).
`oversight`	Optional (Level 2+): the decision conditions (context hash, decision latency, pre-AI decision, risk tier, rationale), so oversight quality is provable.
`signature_ed25519`	Ed25519 signature over the canonical core. Excluded from the signed bytes.
`public_key`	The verification key, base64url. Confirmable against the did document.

The verification algorithm

Small on purpose, so anyone can reimplement it. If any step fails, the Seal is invalid, and it fails in a way that names the reason.

Remove signature_ed25519 and public_key; the rest is the signed core.
Canonicalize the core: JSON with keys sorted and no insignificant whitespace.
Verify the Ed25519 signature over those bytes against public_key.
Independently resolve the key from the did document (did:web to https to /.well-known/did.json) and confirm it matches.
If you have the action, recompute sha256 of its canonical form and confirm it equals content_hash.

Verify in the browser (client side)

// canonical JSON: keys sorted, no spaces (matches the issuer)
function canon(o){
  if(Array.isArray(o)) return '['+o.map(canon).join(',')+']';
  if(o&&typeof o==='object') return '{'+Object.keys(o).sort()
      .map(k=>JSON.stringify(k)+':'+canon(o[k])).join(',')+'}';
  return JSON.stringify(o);
}
async function verify(receipt){
  const core={}; for(const k in receipt)
    if(k!=='signature_ed25519'&&k!=='public_key') core[k]=receipt[k];
  const msg=new TextEncoder().encode(canon(core));
  const key=await crypto.subtle.importKey('raw', b64u(receipt.public_key),
      {name:'Ed25519'}, false, ['verify']);
  return crypto.subtle.verify({name:'Ed25519'}, key,
      b64u(receipt.signature_ed25519), msg);
}

Try the live verifier

Trust root and interoperability

The issuer key is published at did:web:humanseal.world, resolvable over HTTPS.
The receipt is structurally a W3C Verifiable Credential (a signed, tamper-evident claim, verifiable without contacting the issuer).
The signature base (Ed25519 over canonical JSON) is aligned with the emerging IETF signed-action-receipt work, so a Human Seal is interoperable, not proprietary.