┌─────────────┐        ┌─────────────────┐        ┌───────────────┐
│  User App   │ <----> │  Front‑end API  │ <----> │  ZKP Verifier │
└─────▲───────┘        └───────▲─────────┘        └───────▲───────┘
      │                       │                        │
      │   1. Request VC       │   2. Verify ZKP        │
      │   (optional AI)      │   (age ≥ 18)           │
      ▼                       ▼                        ▼
┌─────────────┐        ┌─────────────────┐        ┌───────────────┐
│  Issuer API │        │  AI Doc‑Check   │        │  Credential   │
│ (Gov/3rd‑P) │        │  Service (OCR) │        │  Store (DID)  │
└─────────────┘        └─────────────────┘        └───────────────┘

// 1️⃣ Install dependencies
// npm i @veramo/core @veramo/did-manager @veramo/credential-waltid zkp-lib

import { createAgent } from '@veramo/core';
import { CredentialIssuer } from '@veramo/credential-waltid';
import { DIDManager, MemoryDIDStore } from '@veramo/did-manager';
import { ZKProof } from 'zkp-lib';

// 2️⃣ Set up a minimal Veramo agent (in‑memory for demo)
const agent = createAgent({
  plugins: [
    new DIDManager({ store: new MemoryDIDStore(), defaultProvider: 'did:ethr' }),
    new CredentialIssuer(),
  ],
});

// 3️⃣ Issue a credential after AI‑validated ID upload
async function issueAgeCredential(userId: string, birthYear: number) {
  // Age calculation (client‑side, never sent to server)
  const age = new Date().getFullYear() - birthYear;

  // Create a minimal VC that only contains the claim “over18: true”
  const vc = await agent.createVerifiableCredential({
    credential: {
      '@context': ['https://www.w3.org/2018/credentials/v1'],
      type: ['VerifiableCredential', 'AgeOver18'],
      issuanceDate: new Date().toISOString(),
      credentialSubject: {
        id: `did:example:${userId}`,
        over18: age >= 18,
      },
    },
    proofFormat: 'jwt',
  });

  // Store the VC on a DID‑controlled data vault (optional)
  await agent.dataStoreSaveVerifiableCredential({ verifiableCredential: vc });

  return vc;
}

import { verifyZKProof } from 'zkp-lib';

// Assume `vc` is stored in the browser’s IndexedDB after issuance
async function checkAccess(vc) {
  // 1️⃣ Generate a ZK proof that the VC’s `over18` claim is true
  const proof = await ZKProof.generate({
    statement: 'over18 === true',
    credential: vc,
  });

  // 2️⃣ Send the proof (not the VC) to the back‑end verifier
  const resp = await fetch('/api/verify-proof', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ proof }),
  });

  const { ok } = await resp.json();
  return ok; // true → grant access
}

import express from 'express';
import { verifyZKProof } from 'zkp-lib';

const app = express();
app.use(express.json());

app.post('/api/verify-proof', async (req, res) => {
  const { proof } = req.body;
  const isValid = await verifyZKProof(proof, { statement: 'over18 === true' });

  if (!isValid) return res.status(403).json({ ok: false, error: 'Invalid proof' });
  res.json({ ok: true });
});

app.listen(3000, () => console.log('Verifier listening on :3000'));