Skip to main content

Glossary

Terms are in alphabetical order. Interface labels are in bold as they appear in the app. Where a term has its own page, the definition links to it.

A​

  • AAD (associated data): data that authenticated encryption covers with its tag without encrypting it. Certichain binds each encrypted document to "certichain.doc.v1", the issuer address and the document hash. See Encryption.
  • Access (interface): the holder area page at /access where a requester proves access to a credential with a zero-knowledge proof.
  • Access code: ccaccess1_..., the text a requester gives a holder so the holder can admit them to a credential's access group. It carries a Semaphore identity commitment, an X25519 public key and a checksum.
  • Access gate: the contract CertichainAccessGate that keeps one Semaphore group per credential and records access receipts. See Access gate.
  • Access identity: a Semaphore identity plus an X25519 key pair, derived from a wallet signature or generated at random and saved in a file. See Zero-knowledge proofs.
  • Active set: the contract set the app issues into. Older listed sets are still read for verification. On Sepolia the active set is 0.3.0 as of 2026-10-24.
  • Admin: the single holder of DEFAULT_ADMIN_ROLE on the IssuerRegistry and StatusRegistry. On Sepolia it is a 2-of-3 Safe, with a timelock in front of set 0.5.0. See Admin.
  • Admin delay: the waiting time before a new admin can accept the role under AccessControlDefaultAdminRules.
  • Administrative hold: a suspension placed by the admin rather than the issuer. Only the admin can lift it.
  • AES-256-GCM: the authenticated symmetric cipher used for document encryption.
  • Anchor: the credential record stored in the CredentialRegistry: issuer, subject commitment, document hash, metadata hash, record type, dates and schema version.
  • API envelope: the signed wrapper around every verification API answer. See API envelope.
  • API key: an optional key for higher verification API limits. The server stores only SHA-256 hashes of keys in API_KEYS.
  • API signer: the funds-free key (API_SIGNER_KEY) that signs verification API answers; its address is published as NEXT_PUBLIC_API_SIGNER.
  • AttributeSet: the EIP-712 type an issuer signs over the root of a credential's selective disclosure tree.
  • Award date (awardedOn): an optional display field, a calendar date written YYYY-MM-DD.

B​

  • Binding (holder binding): the link in the HolderRegistry between an issuer's enrolment commitment and a student's wallet, created by redeeming an invitation. See Enrolment.
  • Binding epoch: a counter per enrolment that increases on every bind, unbind or revoke, so older invitations become stale.
  • Bitstring Status List: a W3C format that publishes many credentials' revocation or suspension state as bits in one signed list. See Standards.
  • blobHash: the SHA-256 of an uploaded encrypted container, returned by the upload route so the browser can check the server stored exactly what was sent.
  • Block: a batch of transactions with a number and timestamp. See Blockchain basics.
  • BN254: the elliptic curve over which Semaphore's Groth16 proofs are made.
  • Bulk import (interface): the issuer page at /records/import that issues a cohort of credentials from a CSV or JSON file. See Bulk import.

C​

  • Capability link: a link to /open#<credentialId>.<cid>.<key> that carries a document key in its fragment. Anyone with the link can read the document.
  • Chain id: the number that identifies a network; Sepolia is 11155111, a local Hardhat node is 31337.
  • Challenge: a random 32-byte value a verifier gives a holder, which the holder signs into a disclosure so it cannot be replayed to another verifier.
  • Check a verifiable credential file (interface): the verify page panel that checks an exported VC without a wallet.
  • CID: the content identifier of a file on IPFS, a hash of its stored bytes. See Storage and IPFS.
  • Commitment: a value that fixes data without revealing it until it is opened. See Hashing and commitments.
  • Compact code: the short QR-friendly text forms v1., c1. and d1. used by the phone wallet pilot. See Compact codes.
  • Container: the encrypted form of a document: magic bytes, a canonical JSON header and AES-256-GCM ciphertext. See Encrypted container.
  • Contract account: an Ethereum account controlled by code, such as a Safe. It has no private key.
  • Contract set: one deployment of the v0.3 registries, listed with a label (for example 0.3.0, 0.5.0) in the deployment manifest. See Contract versions and sets.
  • Copy link (interface): copies a verification link or a capability link, depending on the panel.
  • Credential: a signed statement by an issuer about a student, anchored on chain. Called a "record" in the legacy v0.2 interface.
  • Credential id: the EIP-712 digest of the signed credential fields, which is also the key of the anchor on chain.
  • Credential package: the JSON file a holder keeps: signed fields, signature, credential id and, optionally, the CID, document key, display fields, salts and disclosure data. See Credential package.
  • CredentialRegistry: the v0.3 contract that accepts signed credentials and stores anchors. See Credential registry.
  • Cryptosuite: the named algorithm a Data Integrity proof uses, for example certichain-eip712-2026 or eddsa-rdfc-2022.

D​

  • Data Integrity proof: the W3C way of attaching a proof to a JSON-LD document, with a type of DataIntegrityProof and a cryptosuite.
  • DEFAULT_ADMIN_ROLE: the OpenZeppelin role that administers other roles.
  • Deployment manifest: the JSON file that lists the contract sets on a network and names the active one (src/contracts/v03/deployment.<chainId>.json). See Deployment manifest.
  • DID: a decentralized identifier. Certichain uses did:pkh for Ethereum addresses and did:key for the badge key.
  • Disclosure file: what a holder gives a verifier to show chosen fields: the values, their tree paths, the issuer's attestation and the holder's signature over the challenge. See Disclosure file.
  • DisclosureRequest: the EIP-712 type a holder signs to bind a disclosure to a challenge.
  • Display fields: the human-readable credential data (holderName, studentId, programme, award, awardedOn). Only their salted hash is on chain.
  • Document hash (documentHash): the SHA-256 of the issued file, anchored in the credential.
  • Document key: the random 32-byte AES key that encrypts one document. It travels in the package, in grants (wrapped) and in capability links.
  • Domain separation: prefixing hashed or signed data with a purpose label so values made for one purpose cannot be used for another.
  • DPIA: data protection impact assessment. A draft exists in the handbook and awaits legal review. See Privacy design.

E​

  • ECDSA: the signature algorithm Ethereum accounts use, on the secp256k1 curve.
  • Ed25519: a signature scheme used for the standard Open Badge proof.
  • EIP-191: the Ethereum standard for signing plain messages (personal_sign).
  • EIP-712: the Ethereum standard for signing typed, structured data. See Signatures.
  • EIP-4361: Sign-In with Ethereum.
  • Encrypt and upload (interface): the issue form button that encrypts the chosen file in the browser and uploads the container.
  • Encryption key: the X25519 key pair a wallet derives by signing EncryptionKey typed data; it opens documents wrapped to it.
  • Enrolment commitment: the subject commitment made with the stable student salt; the key of a holder binding.
  • EOA (externally owned account): an Ethereum account controlled by a private key.
  • Epoch (access gate): a whole day counted from the Unix epoch; a member can produce one receipt per credential per epoch.
  • ERC-1271: the standard by which a contract wallet approves a signature.
  • Event (log): data a contract emits in a transaction receipt. Certichain rebuilds its lists from events.

F to H​

  • Fingerprint (share): the key id of a share code or access code, written in groups of four characters, for two people to compare over another channel.
  • Gas: the unit of computation a transaction pays for.
  • Gateway (IPFS): an HTTP server that serves IPFS content by CID.
  • Grant file: a file that gives one recipient the document key of one credential, wrapped to their share code. See Sharing files.
  • Groth16: the zk-SNARK proof system Semaphore uses.
  • Group (Semaphore): an on-chain Merkle tree of identity commitments; the gate keeps one per credential.
  • Guardian: an address with GUARDIAN_ROLE that can pause issuance and suspend an issuer, and in contract version 0.5.0 also unpause. See Guardian.
  • HKDF: the key derivation function (RFC 5869) that turns wallet signatures into key seeds.
  • Holder: the student who receives a credential and keeps its package. See Holder.
  • HolderRegistry: the v0.3 contract that stores holder bindings. See Holder registry.
  • HPKE: Hybrid Public Key Encryption (RFC 9180), used to wrap document keys.

I to K​

  • Inbox: the list on the holder's page of credentials issued to their bound wallet, rebuilt from events. See Holder inbox.
  • Indexed topic: an event argument that clients can filter logs by.
  • Invitation: an issuer-signed EIP-712 message that lets one named wallet bind to one enrolment before an expiry. See Invitation file.
  • IPFS: the content-addressed file network where encrypted containers are stored.
  • Issue Record (interface): the submit button of the issue form at /records/add.
  • Issuer: an institution's address registered with a name in the IssuerRegistry. See Issuer.
  • Issuer suspension: a flag in the StatusRegistry that makes all of an issuer's credentials invalid while set.
  • IssuerRegistry: the v0.3 contract that lists issuers, holds the admin and guardian roles and the pause flag. See Issuer registry.
  • JCS (RFC 8785): the JSON Canonicalization Scheme, one exact serialisation of JSON for hashing.
  • JSON-LD: JSON with a @context that gives each property a global meaning; the basis of VCs.
  • keccak-256: the hash function built into Ethereum.
  • Key in charge: the issuer key that currently manages a credential: the original issuer, or its successor after a key retirement.
  • Key retirement: replacing an issuer key with a successor key (contract version 0.5.0), keeping earlier credentials valid. See Key retirement.
  • Key update file: the file an issuer gives a holder after replacing a document key: credential id, new CID and new key.
  • Key version: a number in the key-derivation typed data that allows a wallet's derived keys to be rotated.
  • kid: a key id, the first 8 bytes of SHA-256 of a public key, written as 16 hex characters.

L to N​

  • Lineage: the chain of retired issuer keys and their successors, followed by currentIssuerOf up to 8 hops.
  • Look up a credential (interface): the verifier navigation link to /verify.
  • Manage access (interface): the button on a holder's credential row and the issuer dashboard that opens the access gate panel.
  • Merkle proof: the sibling hashes that prove one leaf belongs to a Merkle root.
  • Merkle tree: a tree of hashes in which each parent hashes its two children.
  • Message (Semaphore): a public value a proof commits to; the gate requires it to be the sender's address.
  • Metadata hash (metadataHash): the keccak-256 of the canonical display fields plus a fresh salt, anchored in the credential.
  • Monitor: the read-only server check that runs on a schedule and posts alerts to a webhook. Off until configured. See Monitoring.
  • Multisig: a wallet that needs several owners' approval, such as a Safe.
  • Nonce (credential): a random 256-bit number in a signed credential; the registry refuses a second use per issuer.
  • Nonce (sign-in): a single-use value the server issues for a SIWE message, valid for 5 minutes.
  • Note hash: the keccak-256 of a free-text note attached to a status change; only the hash is on chain.
  • Nullifier: a public value from a Semaphore proof that is the same for the same identity and scope, used to stop double use.

O to Q​

  • On this phone (interface): the holder link to /wallet, the phone wallet pilot.
  • Open Badge: a credential in the 1EdTech Open Badges 3.0 format. Certichain exports badges from packages. See Standards.
  • OpenAPI: the description format of the verification API, served at /api/v1/openapi.json.
  • Operator: the person who configures and runs a deployment: environment variables, keys, monitor, pinning. See Operator.
  • Padding: zeros added before encryption so the ciphertext reveals the size only to the nearest 64 KiB.
  • Pause: the emergency stop in the IssuerRegistry that stops creating credentials, bindings, record types and access proofs, but not status changes.
  • Pinning: telling an IPFS service to keep a file permanently. Certichain pins with Pinata.
  • Presentation: showing a credential to a verifier, for example as a compact QR code from the phone wallet. See Phone wallet.
  • Publisher (status list): the funds-free key (STATUS_LIST_SIGNER_KEY) that signs status lists; verifiers pin its address.

R​

  • Receipt (access): the AccessProven event the gate emits for a valid proof. It releases nothing.
  • Record type: the kind of credential, a number. Built-in types are 0 to 31; 32 to 999 are reserved; each issuer's own types start at 1000. See Record types.
  • RecordTypeRegistry: the v0.3 contract where issuers register their own record types. See Record type registry.
  • Reason code: a number explaining a status change: 0 Unspecified, 1 Issued in error, 2 Data correction, 3 Fraud or misrepresentation, 4 Academic misconduct, 5 Administrative hold, 6 Issuer key compromise, 7 Holder request; 8 to 999 reserved; 1000 and above issuer-defined.
  • Re-issue: issuing a corrected credential that supersedes an earlier one.
  • Reorganisation (reorg): the chain briefly switching to a different sequence of recent blocks.
  • Replace key (interface): the issuer dashboard action that re-encrypts a document under a fresh key.
  • RFC 6979: deterministic ECDSA; the same key and message give the same signature, which key derivation relies on.
  • Revoked: a final status: the credential is cancelled for good.
  • RPC endpoint: the JSON-RPC server a browser or server uses to read the chain and send transactions.

S​

  • Safe: a multisig smart contract wallet; the Sepolia admin is a 2-of-3 Safe.
  • Salt: random data added before hashing so the hash cannot be guessed.
  • Scan a phone (interface): the verifier link to /present, which reads a holder's QR code.
  • Schema version: a field of the anchor that records the anchor layout version.
  • Scope (Semaphore): the public context of a proof; the gate's scope binds chain, gate, credential and epoch.
  • Selective disclosure: showing chosen display fields without the others. See Selective disclosure.
  • Semaphore: the zero-knowledge group membership protocol the access gate builds on (version 4.14.3).
  • Sepolia: the Ethereum public test network Certichain is deployed on.
  • Session cookie: certichain_session, an HS256 JWT valid for 30 minutes that proves an issuer signed in.
  • SHA-256: the hash function used for document hashes, key ids and file checks.
  • Share code: ccshare1_..., a recipient's public encryption key with a checksum, which a holder uses to make a grant file.
  • SIWE: Sign-In with Ethereum (EIP-4361), how issuers sign in to the upload and document routes.
  • Status: one of None, Active, Suspended, Revoked, Superseded, kept in the StatusRegistry. See Lifecycle.
  • Status list: see Bitstring Status List.
  • StatusRegistry: the v0.3 contract that keeps each credential's status and history. See Status registry.
  • Student salt: the stable salt an issuer's wallet derives for one student by signing StudentSalt typed data.
  • Students (interface): the issuer link to /students/invite, where students are invited to bind their wallets.
  • Subject commitment (subjectCommitment): the salted keccak-256 of the issuer address and the normalised student id, anchored in the credential.
  • Successor: the issuer key that takes over from a retired key.
  • Superseded: a final status for a credential replaced by a newer one, which the status names.
  • Suspended: a temporary status; the credential is not valid until reinstated.

T to Z​

  • Timelock: the CertichainTimelock contract (OpenZeppelin TimelockController) that delays admin actions. See Timelock.
  • Transaction: a signed instruction that changes chain state and costs gas.
  • Trusted setup: the ceremony that produces Groth16 keys. See Zero-knowledge proofs.
  • v0.2: the legacy single-contract generation (AcademicRecords), release v2.0.0. See Legacy v0.2.
  • v0.3: the current generation of small registries, deployed as contract sets.
  • validUntil: an optional expiry time in a credential; 0 means no expiry.
  • Verification API: the signed REST API under /api/v1. Off until its signer key is configured. See REST API.
  • Verifier: anyone checking a credential; no wallet needed. See Verifier.
  • Verifiable credential (VC): a W3C VC 2.0 document; Certichain exports packages as VCs. See Verifiable credential.
  • VersionAnnouncer: an append-only on-chain notice board that records where contract sets live. Clients take addresses from their own configuration and never follow it. See Version announcer.
  • Wallet: software that holds a private key and signs, such as MetaMask.
  • Witness: the private inputs a zero-knowledge prover uses.
  • X25519: the key agreement used inside HPKE for document keys and access identities.
  • zkey: a Groth16 proving key file; Certichain pins and hash-checks them.
  • zk-SNARK: a short, quickly checked zero-knowledge proof.