Build on ORBIS.ID.

# 1 · Provision an organization (owner bearer).
#    DEMO-TENANT LAW: a demonstration org MUST be named so its slug starts
#    with "demo-" and its display name ends with " (Demo)". Never un-marked.
curl -sS https://orbis.id/api/tenants \
  -H 'authorization: Bearer $ORBIS_OPERATOR_TOKEN' \
  -H 'content-type: application/json' \
  -d '{"name":"Demo Acme Freight (Demo)"}'
# → {"slug":"demo-acme-freight-demo","name":"Demo Acme Freight (Demo)","did":"did:web:orbis.id:t:demo-acme-freight-demo"}

# 1b · Register a credential type for it.
#      Claim specs: key | key:date | key:number | key:money | key:bool
#                 | key:array(text) | key:array(object) | key:enum(a|b|c)
#      An unrecognised spec is a hard 400 — never a silently-dropped claim.
curl -sS https://orbis.id/api/types \
  -H 'authorization: Bearer $ORBIS_OPERATOR_TOKEN' \
  -H 'content-type: application/json' \
  -d '{"tenant":"demo-acme-freight-demo","name":"Carrier Licence",
       "claims":["carrier_name","licence_class:enum(A|B|C)","expires:date"]}'

# 2 · Create a credential offer. The offerUri is what you render as a QR.
curl -sS https://orbis.id/api/offers \
  -H 'authorization: Bearer $ORBIS_OPERATOR_TOKEN' \
  -H 'content-type: application/json' \
  -d '{"tenant":"demo-acme-freight-demo","typeId":"carrier-licence",
       "subject":{"carrier_name":"Acme Freight","licence_class":"B","expires":"2027-01-31"}}'
# → {"offerUri":"openid-credential-offer://..."}

# The WALLET then does this part — shown so you can see the whole wire:
curl -sS https://orbis.id/t/demo-acme-freight-demo/token \
  -d 'grant_type=urn:ietf:params:oauth:grant-type:pre-authorized_code' \
  -d 'pre-authorized_code=<from the offer>'
# → {"access_token":"...","c_nonce":"...","expires_in":300}

curl -sS https://orbis.id/t/demo-acme-freight-demo/credential \
  -H 'authorization: Bearer <access_token>' \
  -H 'content-type: application/json' \
  -d '{"credential_configuration_id":"carrier-licence",
       "proof":{"proof_type":"jwt","jwt":"<ES256 JWT, typ openid4vci-proof+jwt, aud=this issuer, nonce=c_nonce>"}}'
# → {"credentials":[{"credential":"<SD-JWT VC>"}]}

# 3 · Hold. The credential lives in the holder's wallet under device-key
#     custody. There is no ORBIS API that reads a holder's wallet: the wallet
#     bridge is authenticated by the DEVICE KEY, and the account id IS the
#     RFC 7638 thumbprint of that key. Nothing an operator holds can forge it.
curl -sS https://orbis.id/api/wallet/<thumbprint>/items
# → {"accountId":"...","fixtures":false,"items":[...]}
#   "fixtures": true means this deployment is serving demonstration data.
#   That marker is an honesty law, not a debug flag — never suppress it.
#   This LIST is open (the wallet reads it with no header); every WRITE —
#   accept, sharing — needs the device key's signature. Pending offers
#   materialize only for an already-enrolled account, so reading this URL
#   with an account id you invented can never make an issuer key sign.

# 4 · Verify — with NO ORBIS account, NO API key, from any origin.
curl -sS https://orbis.id/verify/catalog
# → {"types":[{"id":"...","name":"...","vct":"...","tenant":"...","claims":["..."]}]}

# Ask for exactly the claims you need, bound to YOUR nonce and audience.
curl -sS https://orbis.id/verify/request \
  -H 'content-type: application/json' \
  -d '{"vct":"<vct>","claims":["carrier_name"],
       "nonce":"<your session nonce>","aud":"https://your-app.example"}'
# → {"requestUri":"openid4vp://?request_uri=...","transactionId":"...",
#    "resultToken":"..."}
#   Render requestUri as a QR — NEVER the resultToken. The wallet fetches the
#   request object from https://orbis.id/oid4vp/request/<transactionId> and
#   posts the presentation back to https://orbis.id/oid4vp/response.

# Poll the outcome. "outcome" stays null until the round-trip really completed
# — and until you present the resultToken, because the outcome is yours, not
# the world's. A poll without it reads null forever, exactly like an unknown
# transaction; nothing here ever asks you for an account.
curl -sS https://orbis.id/verify/result/<transactionId> \
  -H 'authorization: Bearer <resultToken>'
# → {"outcome":{"ok":true,"presentation":{...},"presentedNonce":"...","presentedAud":"..."}}
#   presentation.claims carries EXACTLY the claims you asked for. The holder's
#   confirmation key is never served: its thumbprint is that holder's wallet
#   account id.
# → {"outcome":{"ok":false,"error":"<which link of the chain failed>"}}

// Verify an ORBIS credential offline. Zero dependencies, Node and browser.
// Using this package is OPTIONAL: the conformance vectors are the contract.
import { verifyPresentation } from '@orbis-id/verifier';

const didDocument = await (await fetch('https://orbis.id/.well-known/did.json')).json();
const token       = await (await fetch('https://orbis.id/status/1')).text();

const outcome = await verifyPresentation({
  presentation,                                        // the vp_token you received
  didDocument,                                         // the issuer's published did:web document
  statusList: { uri: 'https://orbis.id/status/1', token },
  expected: { audience: 'https://your-app.example', nonce: yourNonce },
});

if (outcome.verdict === 'accept') use(outcome.claims);

// THREE verdicts, not two. "indeterminate" means the check could not be made —
// the credential names a status list and you supplied none, OR it carries no
// "status" claim at all and so declares no revocation mechanism to read. Both
// answer the same way: a credential whose revocation state was never read is
// never accepted. It is never an accept, and treating it as a reject is YOUR
// policy decision to make out loud.
// outcome.checks is the full ledger: ten links, each with its own status
// (passed | failed | not_applicable | not_performed). The verdict is derived
// from that ledger, so a check that did not run can never be reported as one
// that passed.

# 1 · Fetch the vectors. No account, no key, no permission. CORS-open.
curl -sS https://orbis.id/conformance/vectors > vectors.json

# 2 · Point the runner at YOUR implementation, in any language.
npx orbis-conformance --vectors ./vectors.json --cmd './target/release/my-verifier'

# Your command is spawned once and speaks newline-delimited JSON:
#   -> stdin   {"id":"valid","input":{ ...the vector's `input` object verbatim... }}
#   <- stdout  {"id":"valid","verdict":"accept","failure":null,"claims":{...}}
# "verdict" is accept | reject | indeterminate and is the only required field
# besides "id". Exit code 0 when every vector passes, 1 otherwise.

# 3 · Read the report.
#   level 1 (verdict)        16/16  CONFORMANT
#   level 2 (verdict+reason) 16/16  CONFORMANT
# Level 1 is the BINDING contract: the verdict alone. Level 2 also matches the
# failure code and the disclosed claims — recommended, never required. Forcing
# you to adopt ORBIS's enum names would be the chokepoint this exists to prevent.

# 1 · Ask the running instance what it is. No account, no key.
curl -s https://orbis.id/build

# {
#   "commit": "<40-hex>",              the commit this artifact was built from
#   "sourceDigest": "sha256:...",      the content digest recorded AT BUILD TIME
#   "observedSourceDigest": "sha256:...",  recomputed from the files on disk NOW
#   "matches": true|false,
#   "divergence": { "missing": 0, "changed": 0, "extra": 0 },
#   "attestation": { "available": false, "reason": "..." }
# }
#
# Read "attestation" FIRST. It says whether anything outside this server signs
# the commit above, and today the honest answer is no.

# 2 · Recompute the digest from the commit. Needs no ORBIS software:
#      coreutils is the entire trust base.
git checkout <commit-from-step-1>

LC_ALL=C find .orbis package.json package-lock.json tsconfig.json scripts src \
  -type f ! -name '*.test.ts' ! -name '.DS_Store' \
  | LC_ALL=C sort | xargs -n1 sha256sum | sha256sum

# The output must equal "sourceDigest". It is a sha256 over the sorted
# "<sha256>  <path>" lines of every file the deploy artifact contains — so it
# is unaffected by mtimes, file order, permissions or which zip built it.

# 3 · Rebuild the deploy artifact itself, byte for byte.
npx tsx scripts/build-deploy-zip.ts --out deploy.zip
sha256sum deploy.zip

# Must equal the archive digest printed in that release's deploy run.
# The builder refuses a working tree that is not the commit, normalises every
# entry's timestamp to the commit's own, and drops the extra fields that record
# the building machine's access times and uid/gid. What it cannot control is
# the DEFLATE implementation: Info-ZIP 3.0 is what GitHub's runners and macOS
# ship, and a different compressor may produce a different archive digest for
# an identical source tree. That is why step 2, and not this step, is the one
# that decides.

# 4 · Check who signed it — and today, find out that nobody did.
gh attestation verify deploy.zip --repo Jonatans11/OID

# GitHub refuses to create artifact attestations for user-owned PRIVATE
# repositories. Measured, not assumed:
#
#   POST /repos/Jonatans11/OID/attestations
#   422 "Feature not available for user-owned private repositories.
#        To enable this feature, please make this repository public."
#
# The deploy workflow already carries a fully configured attest step, gated on
# that one fact. Until it lifts, steps 1-3 tie the running bytes to a commit;
# nothing ties them to GitHub's word that GitHub built them.

// Verify an ORBIS webhook. Compare bytes, never strings, and never trust
// an unsigned body. Headers ORBIS sends:
//   x-orbis-signature: sha256=<hex>   HMAC-SHA256 of the RAW body, hex
//   x-orbis-event:     <event type>
//   x-orbis-delivery:  <delivery id>  (idempotency key — dedupe on this)
import { createHmac, timingSafeEqual } from 'node:crypto';

export function verifyOrbisWebhook(rawBody: string, header: string | null, secret: string): boolean {
  if (!header) return false;
  const m = /^sha256=([0-9a-f]{64})$/i.exec(header.trim());
  if (!m) return false;
  const expected = Buffer.from(createHmac('sha256', secret).update(rawBody, 'utf8').digest('hex'), 'hex');
  const given = Buffer.from(m[1].toLowerCase(), 'hex');
  return expected.length === given.length && timingSafeEqual(expected, given);
}

// Read the RAW body. If your framework has already parsed and re-serialised
// the JSON, the bytes have changed and the signature will never match.