AffixIO SDK docs

isOnline()

Health probe before batch jobs or cron. Calls GET /api/health and returns true when status is ok.

Signature

async isOnline(): Promise

Example

const ok = await sdk.isOnline();
if (!ok) {
  console.warn("AffixIO API unreachable");
}

buildWitness(circuitId, credential, context?)

Prepare circuit inputs via POST /v1/witness/prepare without proving yet.

Signature

async buildWitness(circuitId: string, credential: AffixCredential, context?: Partial): Promise

Example

const witness = await sdk.buildWitness(
  "kyc",
  credential,
  defaultContext({ required_claim_hash: "verified" }),
);
console.log(witness.inputs);

prove(input)

Generate a SNARK proof for a circuit. Accepts credential+context, witness, or fields.

Signature

async prove(input: ProveInput): Promise

Example

const result = await sdk.prove({
  circuitId: "attested_boolean",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
  requestAttestation: true,
});

verify(circuitId, proof, requestAttestation?)

Verify a proof string without resending the credential.

Signature

async verify(circuitId: string, proof: string, requestAttestation?: boolean): Promise

Example

const check = await sdk.verify("attested_boolean", proofString, true);
if (!check.verified || check.decision === "no") throw new Error("denied");

proveAndVerify(input)

Single-call gate: prove then verify the returned proof.

Signature

async proveAndVerify(input: ProveInput): Promise<{ prove: ProveResult; verify: VerifyResult }>

Example

const { prove, verify } = await sdk.proveAndVerify({
  circuitId: "attested_boolean",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});
if (!verify.verified) throw new Error("gate_failed");

flushOfflineQueue()

Replay jobs from .affix/offline-queue.json.

Signature

async flushOfflineQueue(): Promise

Example

const results = await sdk.flushOfflineQueue();
console.log(`flushed ${results.length} proofs`);

listQueuedJobs()

Inspect pending offline jobs synchronously.

Signature

listQueuedJobs(): QueuedProveJob[]

Example

const pending = sdk.listQueuedJobs();
for (const job of pending) {
  console.log(job.circuit_id, job.attempts);
}

listStoredProofs()

Inspect local proof history (last 500).

Signature

listStoredProofs(): StoredProof[]

Example

const stored = sdk.listStoredProofs();
const latest = stored[stored.length - 1];

kyc

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "kyc" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on kyc, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "kyc",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

attested_boolean

Catalogue domain: Identity / KYC. Witness template: boolean.

Pass circuitId: "attested_boolean" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on attested_boolean, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "attested_boolean",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

attested_membership

Catalogue domain: Identity / KYC. Witness template: membership.

Pass circuitId: "attested_membership" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on attested_membership, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "attested_membership",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

attested_composite

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "attested_composite" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on attested_composite, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "attested_composite",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_biometric_match

Catalogue domain: Identity / KYC. Witness template: boolean_hash.

Pass circuitId: "cross_biometric_match" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_biometric_match, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_biometric_match",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

consent_verification

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "consent_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on consent_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "consent_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_data_consent

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "cross_data_consent" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_data_consent, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_data_consent",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_mfa_verification

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "cross_mfa_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_mfa_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_mfa_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

eligibility

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

simple_yesno

Catalogue domain: Identity / KYC. Witness template: boolean.

Pass circuitId: "simple_yesno" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on simple_yesno, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "simple_yesno",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

yesno

Catalogue domain: Identity / KYC. Witness template: composite.

Pass circuitId: "yesno" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on yesno, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "yesno",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_age

Catalogue domain: Age / health. Witness template: health_age.

Pass circuitId: "health_age" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_age, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_age",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_age_verification

Catalogue domain: Age / health. Witness template: health_age.

Pass circuitId: "health_age_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_age_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_age_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_vaccination_status

Catalogue domain: Age / health. Witness template: date.

Pass circuitId: "health_vaccination_status" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_vaccination_status, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_vaccination_status",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_clinical_trial_eligibility

Catalogue domain: Age / health. Witness template: composite.

Pass circuitId: "health_clinical_trial_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_clinical_trial_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_clinical_trial_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_consent_verification

Catalogue domain: Age / health. Witness template: composite.

Pass circuitId: "health_consent_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_consent_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_consent_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_insurance_eligibility

Catalogue domain: Age / health. Witness template: composite.

Pass circuitId: "health_insurance_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_insurance_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_insurance_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_organ_donor_eligibility

Catalogue domain: Age / health. Witness template: composite.

Pass circuitId: "health_organ_donor_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_organ_donor_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_organ_donor_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_prescription_auth

Catalogue domain: Age / health. Witness template: composite.

Pass circuitId: "health_prescription_auth" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_prescription_auth, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_prescription_auth",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_allergy_check

Catalogue domain: Age / health. Witness template: membership.

Pass circuitId: "health_allergy_check" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_allergy_check, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_allergy_check",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_score_threshold

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "health_score_threshold" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_score_threshold, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_score_threshold",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

health_blood_type_compatibility

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "health_blood_type_compatibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on health_blood_type_compatibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "health_blood_type_compatibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_age_range

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "cross_age_range" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_age_range, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_age_range",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_checkin_age

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "hosp_checkin_age" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_checkin_age, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_checkin_age",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_age_entry

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "ticket_age_entry" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_age_entry, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_age_entry",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_age_restriction

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "ent_age_restriction" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_age_restriction, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_age_restriction",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_age_admission

Catalogue domain: Age / health. Witness template: range.

Pass circuitId: "edu_age_admission" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_age_admission, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_age_admission",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_local_resident

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "ticket_local_resident" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_local_resident, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_local_resident",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_visa_eligibility

Catalogue domain: Residency / travel. Witness template: composite.

Pass circuitId: "travel_visa_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_visa_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_visa_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_residency_proof

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "travel_residency_proof" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_residency_proof, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_residency_proof",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_passport_validity

Catalogue domain: Residency / travel. Witness template: date.

Pass circuitId: "travel_passport_validity" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_passport_validity, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_passport_validity",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_vaccination_req

Catalogue domain: Residency / travel. Witness template: date.

Pass circuitId: "travel_vaccination_req" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_vaccination_req, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_vaccination_req",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_restriction_check

Catalogue domain: Residency / travel. Witness template: boolean.

Pass circuitId: "travel_restriction_check" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_restriction_check, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_restriction_check",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_insurance_coverage

Catalogue domain: Residency / travel. Witness template: boolean.

Pass circuitId: "travel_insurance_coverage" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_insurance_coverage, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_insurance_coverage",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_group_eligibility

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "travel_group_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_group_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_group_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_booking_age

Catalogue domain: Residency / travel. Witness template: range.

Pass circuitId: "travel_booking_age" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_booking_age, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_booking_age",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_frequent_flyer

Catalogue domain: Residency / travel. Witness template: range.

Pass circuitId: "travel_frequent_flyer" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_frequent_flyer, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_frequent_flyer",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

travel_hotel_loyalty

Catalogue domain: Residency / travel. Witness template: range.

Pass circuitId: "travel_hotel_loyalty" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on travel_hotel_loyalty, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "travel_hotel_loyalty",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_residency_duration

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "govt_residency_duration" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_residency_duration, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_residency_duration",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_immigration_status

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "govt_immigration_status" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_immigration_status, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_immigration_status",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_address_proof

Catalogue domain: Residency / travel. Witness template: membership.

Pass circuitId: "cross_address_proof" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_address_proof, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_address_proof",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_attendance_threshold

Catalogue domain: Education. Witness template: range.

Pass circuitId: "edu_attendance_threshold" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_attendance_threshold, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_attendance_threshold",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_enrollment_verification

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_enrollment_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_enrollment_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_enrollment_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_alumni_status

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_alumni_status" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_alumni_status, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_alumni_status",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_degree_completion

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_degree_completion" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_degree_completion, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_degree_completion",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_library_access

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_library_access" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_library_access, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_library_access",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_prerequisites_met

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_prerequisites_met" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_prerequisites_met, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_prerequisites_met",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_research_grant

Catalogue domain: Education. Witness template: membership.

Pass circuitId: "edu_research_grant" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_research_grant, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_research_grant",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_academic_eligibility

Catalogue domain: Education. Witness template: range.

Pass circuitId: "edu_academic_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_academic_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_academic_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

edu_financial_aid

Catalogue domain: Education. Witness template: range.

Pass circuitId: "edu_financial_aid" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on edu_financial_aid, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "edu_financial_aid",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

mortgage_engine

Catalogue domain: Fintech / motor. Witness template: composite.

Pass circuitId: "mortgage_engine" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on mortgage_engine, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "mortgage_engine",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_finance_eligibility

Catalogue domain: Fintech / motor. Witness template: composite.

Pass circuitId: "motor_finance_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_finance_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_finance_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_credit_score_range

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "cross_credit_score_range" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_credit_score_range, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_credit_score_range",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

cross_income_bracket

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "cross_income_bracket" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on cross_income_bracket, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "cross_income_bracket",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_tax_bracket

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "govt_tax_bracket" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_tax_bracket, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_tax_bracket",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_insurance_proof

Catalogue domain: Fintech / motor. Witness template: date.

Pass circuitId: "motor_insurance_proof" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_insurance_proof, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_insurance_proof",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_inspection_valid

Catalogue domain: Fintech / motor. Witness template: date.

Pass circuitId: "motor_inspection_valid" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_inspection_valid, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_inspection_valid",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_license_validity

Catalogue domain: Fintech / motor. Witness template: date.

Pass circuitId: "motor_license_validity" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_license_validity, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_license_validity",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_ownership_verification

Catalogue domain: Fintech / motor. Witness template: membership.

Pass circuitId: "motor_ownership_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_ownership_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_ownership_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_parking_permit

Catalogue domain: Fintech / motor. Witness template: membership.

Pass circuitId: "motor_parking_permit" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_parking_permit, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_parking_permit",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_clean_driving_record

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "motor_clean_driving_record" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_clean_driving_record, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_clean_driving_record",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_emissions_compliance

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "motor_emissions_compliance" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_emissions_compliance, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_emissions_compliance",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_mileage_verification

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "motor_mileage_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_mileage_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_mileage_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

motor_rental_age_check

Catalogue domain: Fintech / motor. Witness template: range.

Pass circuitId: "motor_rental_age_check" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on motor_rental_age_check, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "motor_rental_age_check",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

token_validation

Catalogue domain: Fintech / motor. Witness template: date.

Pass circuitId: "token_validation" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on token_validation, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "token_validation",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_voting_eligibility

Catalogue domain: Government. Witness template: membership.

Pass circuitId: "govt_voting_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_voting_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_voting_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_security_clearance

Catalogue domain: Government. Witness template: boolean.

Pass circuitId: "govt_security_clearance" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_security_clearance, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_security_clearance",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_criminal_record

Catalogue domain: Government. Witness template: boolean.

Pass circuitId: "govt_criminal_record" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_criminal_record, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_criminal_record",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_benefit_entitlement

Catalogue domain: Government. Witness template: membership.

Pass circuitId: "govt_benefit_entitlement" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_benefit_entitlement, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_benefit_entitlement",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_military_service

Catalogue domain: Government. Witness template: membership.

Pass circuitId: "govt_military_service" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_military_service, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_military_service",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_professional_license

Catalogue domain: Government. Witness template: membership.

Pass circuitId: "govt_professional_license" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_professional_license, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_professional_license",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

govt_property_ownership

Catalogue domain: Government. Witness template: membership.

Pass circuitId: "govt_property_ownership" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on govt_property_ownership, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "govt_property_ownership",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

zk_voting

Catalogue domain: Government. Witness template: composite.

Pass circuitId: "zk_voting" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on zk_voting, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "zk_voting",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

merkle_batch

Catalogue domain: Merkle / audit. Witness template: merkle.

Pass circuitId: "merkle_batch" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on merkle_batch, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "merkle_batch",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

audit_proof

Catalogue domain: Merkle / audit. Witness template: audit.

Pass circuitId: "audit_proof" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on audit_proof, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "audit_proof",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

quantum_safe_token

Catalogue domain: Merkle / audit. Witness template: date.

Pass circuitId: "quantum_safe_token" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on quantum_safe_token, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "quantum_safe_token",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

proof_aggregation

Catalogue domain: Merkle / audit. Witness template: composite.

Pass circuitId: "proof_aggregation" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on proof_aggregation, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "proof_aggregation",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

offline_validation

Catalogue domain: Merkle / audit. Witness template: composite.

Pass circuitId: "offline_validation" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on offline_validation, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "offline_validation",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_agent_credentials

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_agent_credentials" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_agent_credentials, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_agent_credentials",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_corporate_rate

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_corporate_rate" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_corporate_rate, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_corporate_rate",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_group_booking

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_group_booking" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_group_booking, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_group_booking",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_longstay_resident

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_longstay_resident" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_longstay_resident, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_longstay_resident",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_loyalty_tier

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "hosp_loyalty_tier" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_loyalty_tier, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_loyalty_tier",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_casino_player

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "hosp_casino_player" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_casino_player, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_casino_player",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_referral_program

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_referral_program" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_referral_program, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_referral_program",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_resort_pass

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_resort_pass" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_resort_pass, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_resort_pass",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

hosp_wedding_package

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "hosp_wedding_package" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on hosp_wedding_package, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "hosp_wedding_package",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_disability_access

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_disability_access" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_disability_access, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_disability_access",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_group_booking

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_group_booking" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_group_booking, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_group_booking",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_presale_access

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_presale_access" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_presale_access, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_presale_access",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_resale_auth

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_resale_auth" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_resale_auth, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_resale_auth",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_season_holder

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_season_holder" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_season_holder, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_season_holder",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_student_discount

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ticket_student_discount" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_student_discount, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_student_discount",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_senior_discount

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "ticket_senior_discount" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_senior_discount, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_senior_discount",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ticket_vip_access

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "ticket_vip_access" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ticket_vip_access, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ticket_vip_access",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_beta_access

Catalogue domain: Agents / hospitality / tickets. Witness template: boolean.

Pass circuitId: "ent_beta_access" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_beta_access, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_beta_access",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_account_standing

Catalogue domain: Agents / hospitality / tickets. Witness template: composite.

Pass circuitId: "ent_account_standing" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_account_standing, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_account_standing",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_creator_verification

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ent_creator_verification" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_creator_verification, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_creator_verification",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_device_license

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "ent_device_license" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_device_license, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_device_license",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_family_plan

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "ent_family_plan" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_family_plan, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_family_plan",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_geo_content_rights

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ent_geo_content_rights" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_geo_content_rights, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_geo_content_rights",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_parental_override

Catalogue domain: Agents / hospitality / tickets. Witness template: composite.

Pass circuitId: "ent_parental_override" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_parental_override, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_parental_override",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_premium_membership

Catalogue domain: Agents / hospitality / tickets. Witness template: range.

Pass circuitId: "ent_premium_membership" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_premium_membership, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_premium_membership",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});

ent_tournament_eligibility

Catalogue domain: Agents / hospitality / tickets. Witness template: membership.

Pass circuitId: "ent_tournament_eligibility" to prove(), buildWitness(), or the CLI --circuit flag when your policy maps to this template.

When you standardise on ent_tournament_eligibility, document the expected claim shape in your internal runbook and keep circuit IDs out of client bundles. Gate failures should return HTTP 403 with proof_id for correlation.

Integration tests can call this ID against the sandbox key, then assert decision === "yes" for happy paths. For deny paths, mismatch required_claim_hash in defaultContext and expect decision === "no".

Programmatic smoke pattern

const result = await sdk.prove({
  circuitId: "ent_tournament_eligibility",
  credential,
  context: defaultContext({ required_claim_hash: "approved" }),
});