@openeudi/openid4vp 0.2.1 → 0.4.0

package/dist/index.js

@@ -1,9 +1,33 @@
-import { splitSdJwt, decodeSdJwt, getClaims } from '@sd-jwt/decode';
-import { decodeProtectedHeader, importX509, jwtVerify, importJWK } from 'jose';
-import { decode } from 'cbor-x';
 import { v4 } from 'uuid';
+import { Encoder, Tag } from 'cbor-x';
+import { importX509, decodeProtectedHeader, jwtVerify, importJWK } from 'jose';
+import { splitSdJwt, decodeSdJwt, getClaims } from '@sd-jwt/decode';
+import { matchQuery, buildSubmission } from '@openeudi/dcql';
+export { DcqlMatchError, DcqlValidationError } from '@openeudi/dcql';
 
-// src/parsers/sd-jwt.parser.ts
+// src/authorization.ts
+function createAuthorizationRequest(input, query) {
+  if (!input.clientId) throw new TypeError("clientId is required");
+  if (!input.nonce) throw new TypeError("nonce is required");
+  if (!input.responseUri) throw new TypeError("responseUri is required");
+  const state = input.state ?? v4();
+  const responseMode = input.responseMode ?? "direct_post";
+  const params = new URLSearchParams({
+    response_type: "vp_token",
+    response_mode: responseMode,
+    response_uri: input.responseUri,
+    client_id: input.clientId,
+    nonce: input.nonce,
+    state,
+    dcql_query: JSON.stringify(query)
+  });
+  return {
+    uri: `openid4vp://authorize?${params.toString()}`,
+    dcqlQuery: query,
+    nonce: input.nonce,
+    state
+  };
+}
 
 // src/errors.ts
 var InvalidSignatureError = class extends Error {
@@ -41,12 +65,619 @@ var NonceValidationError = class extends Error {
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
+var HaipValidationError = class extends Error {
+  code;
+  credentialId;
+  constructor(code, message, credentialId) {
+    super(message);
+    this.name = "HaipValidationError";
+    this.code = code;
+    this.credentialId = credentialId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
 
-// src/parsers/sd-jwt.parser.ts
+// src/haip.ts
+var HAIP_DOCTYPE_NAMESPACES = {
+  "org.iso.18013.5.1.mDL": "org.iso.18013.5.1",
+  "eu.europa.ec.eudi.pid.1": "eu.europa.ec.eudi.pid.1"
+};
+function buildHaipQuery(input) {
+  if (input.claims.length === 0) {
+    throw new HaipValidationError(
+      "NO_CLAIMS",
+      `credential '${input.credentialId}' must declare at least one claim`,
+      input.credentialId
+    );
+  }
+  let meta;
+  let claims;
+  if (input.format === "dc+sd-jwt") {
+    if (!input.vctValues || input.vctValues.length === 0) {
+      throw new HaipValidationError(
+        "MISSING_SDJWT_META",
+        `credential '${input.credentialId}' with format 'dc+sd-jwt' must provide non-empty vctValues`,
+        input.credentialId
+      );
+    }
+    meta = { vct_values: input.vctValues };
+    claims = input.claims.map((c) => ({ path: [c] }));
+  } else {
+    if (!input.doctypeValue) {
+      throw new HaipValidationError(
+        "MISSING_MDOC_META",
+        `credential '${input.credentialId}' with format 'mso_mdoc' must provide doctypeValue`,
+        input.credentialId
+      );
+    }
+    meta = { doctype_value: input.doctypeValue };
+    const namespace = HAIP_DOCTYPE_NAMESPACES[input.doctypeValue] ?? input.doctypeValue;
+    claims = input.claims.map((c) => ({ path: [namespace, c] }));
+  }
+  const credential = {
+    id: input.credentialId,
+    format: input.format,
+    meta,
+    claims
+  };
+  if (input.trustedAuthorities && input.trustedAuthorities.length > 0) {
+    credential.trusted_authorities = input.trustedAuthorities;
+  }
+  return { credentials: [credential] };
+}
+var HAIP_FORMATS = /* @__PURE__ */ new Set(["dc+sd-jwt", "mso_mdoc"]);
+function validateHaipQuery(query) {
+  if (!query.credentials || query.credentials.length === 0) {
+    throw new HaipValidationError(
+      "EMPTY_QUERY",
+      "query.credentials must have at least one entry"
+    );
+  }
+  if (query.credential_sets !== void 0) {
+    throw new HaipValidationError(
+      "CREDENTIAL_SETS_DISALLOWED",
+      "credential_sets are not permitted in HAIP-minimal"
+    );
+  }
+  for (const credential of query.credentials) {
+    if (!HAIP_FORMATS.has(credential.format)) {
+      throw new HaipValidationError(
+        "UNSUPPORTED_FORMAT",
+        `credential '${credential.id}' uses unsupported format '${credential.format}' (allowed: dc+sd-jwt, mso_mdoc)`,
+        credential.id
+      );
+    }
+    if (credential.format === "dc+sd-jwt") {
+      const vctValues = credential.meta?.vct_values;
+      if (!vctValues || vctValues.length === 0) {
+        throw new HaipValidationError(
+          "MISSING_SDJWT_META",
+          `credential '${credential.id}' with format 'dc+sd-jwt' must set meta.vct_values`,
+          credential.id
+        );
+      }
+    }
+    if (credential.format === "mso_mdoc") {
+      if (typeof credential.meta?.doctype_value !== "string") {
+        throw new HaipValidationError(
+          "MISSING_MDOC_META",
+          `credential '${credential.id}' with format 'mso_mdoc' must set meta.doctype_value`,
+          credential.id
+        );
+      }
+    }
+    if (!credential.claims || credential.claims.length === 0) {
+      throw new HaipValidationError(
+        "NO_CLAIMS",
+        `credential '${credential.id}' must declare at least one claim`,
+        credential.id
+      );
+    }
+    if (credential.claim_sets !== void 0) {
+      throw new HaipValidationError(
+        "CLAIM_SETS_DISALLOWED",
+        `credential '${credential.id}' uses claim_sets, not permitted in HAIP-minimal`,
+        credential.id
+      );
+    }
+  }
+}
+function isHaipQuery(query) {
+  try {
+    validateHaipQuery(query);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var decoder = new Encoder({ mapsAsObjects: false, useRecords: false });
+var HEADER_ALG = 1;
+var HEADER_X5CHAIN = 33;
+var COSE_ALG_TO_NAME = {
+  [-7]: "ES256",
+  [-35]: "ES384",
+  [-36]: "ES512"
+};
+function decodeCoseSign1(bytes) {
+  let outer = decoder.decode(bytes);
+  if (outer instanceof Tag && outer.tag === 18) {
+    const tagValue = outer.value;
+    outer = tagValue instanceof Uint8Array ? decoder.decode(tagValue) : tagValue;
+  }
+  if (!Array.isArray(outer) || outer.length !== 4) {
+    throw new MalformedCredentialError("COSE_Sign1 must be a CBOR array of length 4");
+  }
+  const [protectedHeaderBytes, unprotectedHeader, payloadRaw, signature] = outer;
+  if (!(protectedHeaderBytes instanceof Uint8Array)) {
+    throw new MalformedCredentialError("COSE_Sign1 protected header must be a bstr");
+  }
+  if (!(unprotectedHeader instanceof Map)) {
+    throw new MalformedCredentialError("COSE_Sign1 unprotected header must be a Map");
+  }
+  if (!(signature instanceof Uint8Array)) {
+    throw new MalformedCredentialError("COSE_Sign1 signature must be a bstr");
+  }
+  let protectedHeader;
+  try {
+    const decoded = decoder.decode(protectedHeaderBytes);
+    if (!(decoded instanceof Map)) {
+      throw new Error("protected header not a Map");
+    }
+    protectedHeader = decoded;
+  } catch {
+    throw new MalformedCredentialError("COSE_Sign1 protected header is not decodable CBOR");
+  }
+  const algLabel = protectedHeader.get(HEADER_ALG);
+  const alg = typeof algLabel === "number" ? COSE_ALG_TO_NAME[algLabel] : void 0;
+  if (!alg) {
+    throw new MalformedCredentialError(`COSE_Sign1 uses unknown alg label: ${String(algLabel)}`);
+  }
+  let payload;
+  if (payloadRaw instanceof Uint8Array) {
+    payload = payloadRaw;
+  } else if (payloadRaw instanceof Tag && payloadRaw.tag === 24 && payloadRaw.value instanceof Uint8Array) {
+    payload = payloadRaw.value;
+  } else {
+    throw new MalformedCredentialError("COSE_Sign1 payload must be a byte string");
+  }
+  const x5raw = unprotectedHeader.get(HEADER_X5CHAIN);
+  let x5chain;
+  if (x5raw === void 0) {
+    throw new MalformedCredentialError("COSE_Sign1 missing x5chain in unprotected header (label 33)");
+  }
+  if (x5raw instanceof Uint8Array) {
+    x5chain = [x5raw];
+  } else if (Array.isArray(x5raw) && x5raw.every((v) => v instanceof Uint8Array)) {
+    x5chain = x5raw;
+  } else {
+    throw new MalformedCredentialError("COSE_Sign1 x5chain must be a bstr or array of bstr");
+  }
+  return {
+    protectedHeaderBytes,
+    protectedHeader,
+    unprotectedHeader,
+    payload,
+    signature,
+    x5chain,
+    alg
+  };
+}
+var ALG_TO_HASH = {
+  ES256: "SHA-256",
+  ES384: "SHA-384",
+  ES512: "SHA-512"
+};
+async function verifyCoseSign1(coseSign1, publicKey, allowedAlgorithms) {
+  if (!allowedAlgorithms.includes(coseSign1.alg)) {
+    throw new MalformedCredentialError(`COSE_Sign1 algorithm ${coseSign1.alg} not in allowlist`);
+  }
+  const hashAlg = ALG_TO_HASH[coseSign1.alg];
+  if (!hashAlg) {
+    throw new MalformedCredentialError(`no hash mapping for alg ${coseSign1.alg}`);
+  }
+  const sigStructure = ["Signature1", coseSign1.protectedHeaderBytes, new Uint8Array(0), coseSign1.payload];
+  const sigInput = decoder.encode(sigStructure);
+  const ok = await crypto.subtle.verify(
+    { name: "ECDSA", hash: hashAlg },
+    publicKey,
+    new Uint8Array(coseSign1.signature),
+    sigInput
+  );
+  if (!ok) {
+    throw new MalformedCredentialError("COSE_Sign1 signature verification failed");
+  }
+}
+var decoder2 = new Encoder({ mapsAsObjects: false, useRecords: false });
+var ALLOWED_HASH_ALGS = /* @__PURE__ */ new Set(["SHA-256", "SHA-384", "SHA-512"]);
+async function computeItemDigest(itemBytes, digestAlgorithm) {
+  if (!ALLOWED_HASH_ALGS.has(digestAlgorithm)) {
+    throw new MalformedCredentialError(`Unknown digest algorithm: ${digestAlgorithm}`);
+  }
+  const buf = await crypto.subtle.digest(digestAlgorithm, new Uint8Array(itemBytes));
+  return new Uint8Array(buf);
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function unwrapItemMap(itemBytes) {
+  let decoded;
+  try {
+    decoded = decoder2.decode(itemBytes);
+  } catch {
+    throw new MalformedCredentialError("IssuerSignedItem is not decodable CBOR");
+  }
+  let inner;
+  if (decoded instanceof Tag && decoded.tag === 24 && decoded.value instanceof Uint8Array) {
+    inner = decoder2.decode(decoded.value);
+  } else if (decoded !== null && typeof decoded === "object" && !(decoded instanceof Tag) && !(decoded instanceof Map) && !(decoded instanceof Uint8Array) && "value" in decoded && decoded.value instanceof Uint8Array) {
+    inner = decoder2.decode(decoded.value);
+  } else if (decoded instanceof Map) {
+    inner = decoded;
+  } else {
+    throw new MalformedCredentialError("IssuerSignedItem must be a tag-24 wrapped CBOR Map");
+  }
+  if (!(inner instanceof Map)) {
+    throw new MalformedCredentialError("IssuerSignedItem must decode to a Map");
+  }
+  return inner;
+}
+async function verifyAllDigests(nameSpaces, mso) {
+  for (const [ns, items] of nameSpaces) {
+    const expected = mso.valueDigests.get(ns);
+    if (!expected) {
+      throw new MalformedCredentialError(`namespace ${ns} has no valueDigests entry in MSO`);
+    }
+    for (const itemBytes of items) {
+      const hash = await computeItemDigest(itemBytes, mso.digestAlgorithm);
+      const item = unwrapItemMap(itemBytes);
+      const digestID = item.get("digestID");
+      if (typeof digestID !== "number") {
+        throw new MalformedCredentialError("IssuerSignedItem missing digestID");
+      }
+      const expectedDigest = expected.get(digestID);
+      if (!expectedDigest) {
+        throw new MalformedCredentialError(`digestID ${digestID} missing from MSO valueDigests[${ns}]`);
+      }
+      if (!bytesEqual(hash, expectedDigest)) {
+        throw new MalformedCredentialError(`digest mismatch for ns=${ns} digestID=${digestID}`);
+      }
+    }
+  }
+}
+var decoder3 = new Encoder({ mapsAsObjects: false, useRecords: false });
+function decodeDateLike(value) {
+  if (value instanceof Date) return value;
+  if (value instanceof Tag) {
+    if (value.tag === 0 && typeof value.value === "string") {
+      return new Date(value.value);
+    }
+    if (value.tag === 1 && typeof value.value === "number") {
+      return new Date(value.value * 1e3);
+    }
+    if (value.tag === 1004 && typeof value.value === "string") {
+      return new Date(value.value);
+    }
+  }
+  if (typeof value === "string") {
+    return new Date(value);
+  }
+  throw new MalformedCredentialError(`unsupported date encoding in MSO: ${typeof value}`);
+}
+function decodeMso(payload) {
+  let raw;
+  try {
+    raw = decoder3.decode(payload);
+    if (raw instanceof Tag && raw.tag === 24 && raw.value instanceof Uint8Array) {
+      raw = decoder3.decode(raw.value);
+    } else if (raw !== null && typeof raw === "object" && !(raw instanceof Tag) && !(raw instanceof Map) && !(raw instanceof Uint8Array) && "value" in raw && raw.value instanceof Uint8Array) {
+      raw = decoder3.decode(raw.value);
+    }
+  } catch (err) {
+    if (err instanceof MalformedCredentialError) throw err;
+    throw new MalformedCredentialError("MSO payload is not decodable CBOR");
+  }
+  if (!(raw instanceof Map)) {
+    throw new MalformedCredentialError("MSO must be a CBOR Map");
+  }
+  const m = raw;
+  const version = m.get("version");
+  if (typeof version !== "string") {
+    throw new MalformedCredentialError("MSO.version must be a string");
+  }
+  const digestAlgorithm = m.get("digestAlgorithm");
+  if (typeof digestAlgorithm !== "string") {
+    throw new MalformedCredentialError("MSO.digestAlgorithm must be a string");
+  }
+  const docType = m.get("docType");
+  if (typeof docType !== "string") {
+    throw new MalformedCredentialError("MSO.docType must be a string");
+  }
+  const vdRaw = m.get("valueDigests");
+  if (!(vdRaw instanceof Map)) {
+    throw new MalformedCredentialError("MSO.valueDigests must be a Map");
+  }
+  const valueDigests = /* @__PURE__ */ new Map();
+  for (const [ns, inner] of vdRaw.entries()) {
+    if (typeof ns !== "string" || !(inner instanceof Map)) {
+      throw new MalformedCredentialError("MSO.valueDigests entry malformed");
+    }
+    const perNs = /* @__PURE__ */ new Map();
+    for (const [id, digest] of inner.entries()) {
+      if (typeof id !== "number" || !(digest instanceof Uint8Array)) {
+        throw new MalformedCredentialError("MSO digest entry must map number\u2192bstr");
+      }
+      perNs.set(id, digest);
+    }
+    valueDigests.set(ns, perNs);
+  }
+  const viRaw = m.get("validityInfo");
+  if (!(viRaw instanceof Map)) {
+    throw new MalformedCredentialError("MSO.validityInfo must be a Map");
+  }
+  const vi = viRaw;
+  const validityInfo = {
+    signed: decodeDateLike(vi.get("signed")),
+    validFrom: decodeDateLike(vi.get("validFrom")),
+    validUntil: decodeDateLike(vi.get("validUntil"))
+  };
+  if (vi.has("expectedUpdate")) {
+    validityInfo.expectedUpdate = decodeDateLike(vi.get("expectedUpdate"));
+  }
+  return { version, digestAlgorithm, valueDigests, docType, validityInfo };
+}
+function validateMsoValidity(mso, now) {
+  const { signed, validFrom, validUntil } = mso.validityInfo;
+  if (signed.getTime() > now.getTime()) {
+    throw new MalformedCredentialError(`MSO signed=${signed.toISOString()} is in the future`);
+  }
+  if (validFrom.getTime() > now.getTime()) {
+    throw new MalformedCredentialError(`MSO validFrom=${validFrom.toISOString()} is in the future`);
+  }
+  if (validFrom.getTime() > validUntil.getTime()) {
+    throw new MalformedCredentialError("MSO validFrom is after validUntil");
+  }
+  if (signed.getTime() < validFrom.getTime() || signed.getTime() > validUntil.getTime()) {
+    throw new MalformedCredentialError("MSO signed is outside the validity window");
+  }
+  if (validUntil.getTime() < now.getTime()) {
+    throw new ExpiredCredentialError(`MSO validUntil=${validUntil.toISOString()} is in the past`);
+  }
+}
+function validateMsoDocType(mso, expectedDocType) {
+  if (mso.docType !== expectedDocType) {
+    throw new MalformedCredentialError(`MSO docType=${mso.docType} does not match expected ${expectedDocType}`);
+  }
+}
+
+// src/parsers/mdoc.parser.ts
+var decoder4 = new Encoder({ mapsAsObjects: false, useRecords: false });
+var encoder = new Encoder({ mapsAsObjects: false, useRecords: false });
 var DEFAULT_ALLOWED_ALGORITHMS = ["ES256", "ES384", "ES512"];
+function bytesEqual2(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function derToPem(der) {
+  let binary = "";
+  for (const b of der) binary += String.fromCharCode(b);
+  const b64 = globalThis.btoa(binary);
+  const lines = b64.match(/.{1,64}/g) || [];
+  return `-----BEGIN CERTIFICATE-----
+${lines.join("\n")}
+-----END CERTIFICATE-----`;
+}
+function extractCountryHintFromCert(_certDer) {
+  return "";
+}
+function extractRawItemBytes(item) {
+  if (item instanceof Tag && item.tag === 24 && item.value instanceof Uint8Array) {
+    return item.value;
+  }
+  if (item instanceof Uint8Array) {
+    return item;
+  }
+  if (item !== null && typeof item === "object" && !(item instanceof Tag) && !(item instanceof Map) && "value" in item && item.value instanceof Uint8Array) {
+    return item.value;
+  }
+  throw new MalformedCredentialError("IssuerSignedItem must be a tag-24 byte string");
+}
+function mapRawToClaims(nameSpaces) {
+  const flat = {};
+  const namespaced = {};
+  for (const [ns, items] of nameSpaces.entries()) {
+    const nsBucket = namespaced[ns] ?? {};
+    for (const itemBytes of items) {
+      let decoded;
+      try {
+        decoded = decoder4.decode(itemBytes);
+      } catch {
+        continue;
+      }
+      let inner;
+      if (decoded instanceof Tag && decoded.tag === 24 && decoded.value instanceof Uint8Array) {
+        inner = decoder4.decode(decoded.value);
+      } else if (decoded !== null && typeof decoded === "object" && !(decoded instanceof Tag) && !(decoded instanceof Map) && !(decoded instanceof Uint8Array) && "value" in decoded && decoded.value instanceof Uint8Array) {
+        inner = decoder4.decode(decoded.value);
+      } else if (decoded instanceof Map) {
+        inner = decoded;
+      } else {
+        continue;
+      }
+      if (inner instanceof Map) {
+        const id = inner.get("elementIdentifier");
+        const val = inner.get("elementValue");
+        if (typeof id === "string") {
+          flat[id] = val;
+          nsBucket[id] = val;
+        }
+      }
+    }
+    namespaced[ns] = nsBucket;
+  }
+  return { flat, namespaced };
+}
+var MdocParser = class {
+  format = "mdoc";
+  /**
+   * Returns true when the token is binary data (Uint8Array or Buffer),
+   * indicating a CBOR-encoded mDOC DeviceResponse.
+   * Buffer extends Uint8Array, so `instanceof Uint8Array` catches both.
+   */
+  canParse(vpToken) {
+    return vpToken instanceof Uint8Array;
+  }
+  /**
+   * Parses and validates an mDOC DeviceResponse token.
+   *
+   * @throws {MalformedCredentialError} when the CBOR structure cannot be decoded
+   *   or does not match the expected DeviceResponse format
+   */
+  async parse(vpToken, options) {
+    if (!(vpToken instanceof Uint8Array)) {
+      throw new MalformedCredentialError("mDOC vpToken must be a Uint8Array");
+    }
+    const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS;
+    let deviceResponse;
+    try {
+      const decoded = decoder4.decode(vpToken);
+      if (!(decoded instanceof Map)) throw new Error();
+      deviceResponse = decoded;
+    } catch {
+      throw new MalformedCredentialError("vpToken is not a CBOR DeviceResponse Map");
+    }
+    const docs = deviceResponse.get("documents");
+    if (!Array.isArray(docs) || docs.length === 0) {
+      throw new MalformedCredentialError("DeviceResponse has no documents");
+    }
+    const document = docs[0];
+    if (!(document instanceof Map)) {
+      throw new MalformedCredentialError("document must be a Map");
+    }
+    const issuerSigned = document.get("issuerSigned");
+    if (!(issuerSigned instanceof Map)) {
+      throw new MalformedCredentialError("document.issuerSigned must be a Map");
+    }
+    const issuerAuth = issuerSigned.get("issuerAuth");
+    if (!Array.isArray(issuerAuth)) {
+      throw new MalformedCredentialError("issuerAuth must be a COSE_Sign1 array");
+    }
+    const issuerAuthBytes = encoder.encode(issuerAuth);
+    const cose = decodeCoseSign1(issuerAuthBytes);
+    if (!allowedAlgorithms.includes(cose.alg)) {
+      return {
+        valid: false,
+        format: this.format,
+        claims: {},
+        issuer: { certificate: new Uint8Array(), country: "" },
+        error: `Unsupported algorithm: ${cose.alg}`
+      };
+    }
+    const issuerCertBytes = cose.x5chain[0];
+    if (!issuerCertBytes) {
+      throw new MalformedCredentialError("Missing issuer certificate in x5chain");
+    }
+    if (options.trustedCertificates.length === 0) {
+      if (options.skipTrustCheck !== true) {
+        throw new MalformedCredentialError(
+          "trustedCertificates must not be empty unless skipTrustCheck is true"
+        );
+      }
+    } else {
+      const trusted = options.trustedCertificates.some((t) => bytesEqual2(t, issuerCertBytes));
+      if (!trusted) {
+        return {
+          valid: false,
+          format: this.format,
+          claims: {},
+          issuer: { certificate: issuerCertBytes, country: "" },
+          error: "Issuer certificate is not trusted"
+        };
+      }
+    }
+    const publicKey = await importX509(derToPem(issuerCertBytes), cose.alg);
+    try {
+      await verifyCoseSign1(cose, publicKey, allowedAlgorithms);
+    } catch (err) {
+      if (err instanceof MalformedCredentialError) {
+        return {
+          valid: false,
+          format: this.format,
+          claims: {},
+          issuer: { certificate: issuerCertBytes, country: "" },
+          error: err.message
+        };
+      }
+      throw err;
+    }
+    const mso = decodeMso(cose.payload);
+    try {
+      validateMsoValidity(mso, /* @__PURE__ */ new Date());
+    } catch (err) {
+      if (err instanceof ExpiredCredentialError) {
+        return {
+          valid: false,
+          format: this.format,
+          claims: {},
+          issuer: { certificate: issuerCertBytes, country: "" },
+          error: "Credential expired"
+        };
+      }
+      throw err;
+    }
+    if (options.expectedDocType !== void 0) {
+      try {
+        validateMsoDocType(mso, options.expectedDocType);
+      } catch (err) {
+        if (err instanceof MalformedCredentialError) {
+          return {
+            valid: false,
+            format: this.format,
+            claims: {},
+            issuer: { certificate: issuerCertBytes, country: "" },
+            error: err.message
+          };
+        }
+        throw err;
+      }
+    }
+    const nsRaw = issuerSigned.get("nameSpaces");
+    if (!(nsRaw instanceof Map)) {
+      throw new MalformedCredentialError("issuerSigned.nameSpaces must be a Map");
+    }
+    const nameSpaces = /* @__PURE__ */ new Map();
+    for (const [ns, items] of nsRaw.entries()) {
+      if (typeof ns !== "string" || !Array.isArray(items)) {
+        throw new MalformedCredentialError("nameSpaces entry malformed");
+      }
+      nameSpaces.set(ns, items.map(extractRawItemBytes));
+    }
+    await verifyAllDigests(nameSpaces, mso);
+    const { flat: claims, namespaced: namespacedClaims } = mapRawToClaims(nameSpaces);
+    const issuer = {
+      certificate: issuerCertBytes,
+      country: extractCountryHintFromCert()
+    };
+    return {
+      valid: true,
+      format: this.format,
+      claims,
+      issuer,
+      docType: mso.docType,
+      namespacedClaims
+    };
+  }
+};
+var DEFAULT_ALLOWED_ALGORITHMS2 = ["ES256", "ES384", "ES512"];
 var sha256Hasher = async (data, _alg) => {
-  const encoder = new TextEncoder();
-  const input = typeof data === "string" ? encoder.encode(data) : data;
+  const encoder2 = new TextEncoder();
+  const input = typeof data === "string" ? encoder2.encode(data) : data;
   const hashBuffer = await crypto.subtle.digest("SHA-256", input);
   return new Uint8Array(hashBuffer);
 };
@@ -68,14 +699,14 @@ function base64ToBytes(base64) {
   }
   return bytes;
 }
-function bytesEqual(a, b) {
+function bytesEqual3(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
     if (a[i] !== b[i]) return false;
   }
   return true;
 }
-function derToPem(base64Der) {
+function derToPem2(base64Der) {
   const lines = base64Der.match(/.{1,64}/g) || [];
   return `-----BEGIN CERTIFICATE-----
 ${lines.join("\n")}
@@ -132,7 +763,7 @@ var SdJwtParser = class {
     if (typeof vpToken !== "string") {
       throw new MalformedCredentialError("VP token must be a string");
     }
-    const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS;
+    const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS2;
     const invalidResult = (error) => ({
       valid: false,
       format: this.format,
@@ -163,7 +794,7 @@ var SdJwtParser = class {
     let issuerKey;
     let issuerCertBytes;
     try {
-      issuerKey = await importX509(derToPem(x5cArray[0]), alg);
+      issuerKey = await importX509(derToPem2(x5cArray[0]), alg);
       issuerCertBytes = base64ToBytes(x5cArray[0]);
     } catch (err) {
       if (err instanceof MalformedCredentialError) throw err;
@@ -188,7 +819,7 @@ var SdJwtParser = class {
         );
       }
     } else {
-      const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual(trusted, issuerCertBytes));
+      const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual3(trusted, issuerCertBytes));
       if (!isTrusted) {
         return invalidResult("Issuer certificate is not trusted");
       }
@@ -255,226 +886,16 @@ var SdJwtParser = class {
     } catch {
       throw new MalformedCredentialError("Failed to decode SD-JWT disclosures");
     }
+    const vct = typeof payload["vct"] === "string" ? payload["vct"] : void 0;
     return {
       valid: true,
       format: this.format,
       claims: mapToCredentialClaims(resolvedClaims),
-      issuer: issuerInfo
-    };
-  }
-};
-function isBinaryData(value) {
-  return value instanceof Uint8Array;
-}
-function bytesEqual2(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function extractCertificateFromIssuerAuth(issuerAuth) {
-  const unprotected = issuerAuth[1];
-  if (unprotected && typeof unprotected === "object") {
-    const certFromUnprotected = extractX5Chain(unprotected);
-    if (certFromUnprotected) return certFromUnprotected;
-  }
-  const protectedHeader = issuerAuth[0];
-  if (isBinaryData(protectedHeader)) {
-    try {
-      const decoded = decode(protectedHeader);
-      if (decoded && typeof decoded === "object") {
-        const certFromProtected = extractX5Chain(decoded);
-        if (certFromProtected) return certFromProtected;
-      }
-    } catch {
-    }
-    return new Uint8Array(protectedHeader);
-  }
-  return new Uint8Array();
-}
-function extractX5Chain(header) {
-  if (header instanceof Map) {
-    const cert = header.get(33);
-    if (isBinaryData(cert)) {
-      return new Uint8Array(cert);
-    }
-  } else if (typeof header === "object" && header !== null) {
-    const rec = header;
-    const cert = rec[33] ?? rec["x5chain"] ?? rec["33"];
-    if (isBinaryData(cert)) {
-      return new Uint8Array(cert);
-    }
-  }
-  return null;
-}
-function mapToCredentialClaims2(items) {
-  const claims = {};
-  for (const item of items) {
-    const key = item.elementIdentifier;
-    const value = item.elementValue;
-    switch (key) {
-      case "age_over_18":
-        if (typeof value === "boolean") claims.age_over_18 = value;
-        break;
-      case "age_over_21":
-        if (typeof value === "boolean") claims.age_over_21 = value;
-        break;
-      case "resident_country":
-        if (typeof value === "string") claims.resident_country = value;
-        break;
-      case "nationality":
-        if (typeof value === "string") claims.nationality = value;
-        break;
-      case "family_name_birth":
-        if (typeof value === "string") claims.family_name_birth = value;
-        break;
-      default:
-        claims[key] = value;
-        break;
-    }
-  }
-  return claims;
-}
-function extractValidityPeriod(issuerAuth) {
-  const payload = issuerAuth[2];
-  if (!payload) return {};
-  try {
-    const decoded = isBinaryData(payload) ? decode(payload) : payload;
-    if (decoded && typeof decoded === "object") {
-      const obj = decoded;
-      const validityInfo = obj["validityInfo"];
-      if (validityInfo) {
-        return {
-          validFrom: validityInfo["validFrom"] instanceof Date ? validityInfo["validFrom"] : typeof validityInfo["validFrom"] === "string" ? new Date(validityInfo["validFrom"]) : void 0,
-          validUntil: validityInfo["validUntil"] instanceof Date ? validityInfo["validUntil"] : typeof validityInfo["validUntil"] === "string" ? new Date(validityInfo["validUntil"]) : void 0
-        };
-      }
-    }
-  } catch {
-  }
-  return {};
-}
-var MdocParser = class {
-  format = "mdoc";
-  /**
-   * Returns true when the token is binary data (Uint8Array or Buffer),
-   * indicating a CBOR-encoded mDOC DeviceResponse.
-   */
-  canParse(vpToken) {
-    return isBinaryData(vpToken);
-  }
-  /**
-   * Parses and validates an mDOC DeviceResponse token.
-   *
-   * @throws {MalformedCredentialError} when the CBOR structure cannot be decoded
-   *   or does not match the expected DeviceResponse format
-   */
-  async parse(vpToken, options) {
-    if (!isBinaryData(vpToken)) {
-      throw new MalformedCredentialError("VP token must be a Uint8Array or Buffer");
-    }
-    const invalidResult = (error) => ({
-      valid: false,
-      format: this.format,
-      claims: {},
-      issuer: { certificate: new Uint8Array(), country: "" },
-      error
-    });
-    let deviceResponse;
-    try {
-      deviceResponse = decode(vpToken);
-    } catch {
-      throw new MalformedCredentialError("Failed to decode CBOR DeviceResponse");
-    }
-    if (!deviceResponse || typeof deviceResponse !== "object" || !Array.isArray(deviceResponse.documents) || deviceResponse.documents.length === 0) {
-      throw new MalformedCredentialError("Invalid DeviceResponse structure: missing or empty documents array");
-    }
-    const document = deviceResponse.documents[0];
-    if (!document.issuerSigned || !document.issuerSigned.nameSpaces || !document.issuerSigned.issuerAuth) {
-      throw new MalformedCredentialError("Invalid mDOC document: missing issuerSigned data");
-    }
-    const issuerAuth = document.issuerSigned.issuerAuth;
-    if (!Array.isArray(issuerAuth) || issuerAuth.length < 4) {
-      throw new MalformedCredentialError("Invalid issuerAuth: expected COSE_Sign1 array with 4 elements");
-    }
-    const issuerCertBytes = extractCertificateFromIssuerAuth(issuerAuth);
-    const issuerInfo = {
-      certificate: issuerCertBytes,
-      country: ""
-    };
-    if (options.trustedCertificates.length === 0) {
-      if (options.skipTrustCheck !== true) {
-        throw new MalformedCredentialError(
-          "trustedCertificates must not be empty unless skipTrustCheck is true"
-        );
-      }
-    } else {
-      const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual2(trusted, issuerCertBytes));
-      if (!isTrusted) {
-        return invalidResult("Issuer certificate is not trusted");
-      }
-    }
-    const { validUntil } = extractValidityPeriod(issuerAuth);
-    if (validUntil) {
-      const now = /* @__PURE__ */ new Date();
-      if (validUntil < now) {
-        return invalidResult("Credential has expired");
-      }
-    }
-    const pidNamespace = "eu.europa.ec.eudi.pid.1";
-    const nameSpaces = document.issuerSigned.nameSpaces;
-    const items = nameSpaces[pidNamespace] ?? nameSpaces[document.docType] ?? Object.values(nameSpaces)[0] ?? [];
-    const claims = mapToCredentialClaims2(items);
-    if (claims.resident_country && typeof claims.resident_country === "string") {
-      issuerInfo.country = claims.resident_country;
-    }
-    return {
-      valid: true,
-      format: this.format,
-      claims,
-      issuer: issuerInfo
+      issuer: issuerInfo,
+      ...vct !== void 0 ? { vct } : {}
     };
   }
 };
-function createAuthorizationRequest(input) {
-  const state = input.state ?? v4();
-  const presentationDefinition = {
-    id: v4(),
-    input_descriptors: input.requestedAttributes.map((attr, index) => ({
-      id: `descriptor_${index}`,
-      format: Object.fromEntries(
-        input.acceptedFormats.map((fmt) => {
-          if (fmt === "sd-jwt-vc") return ["vc+sd-jwt", { "sd-jwt_alg_values": ["ES256"] }];
-          return ["mso_mdoc", { alg: ["ES256"] }];
-        })
-      ),
-      constraints: {
-        fields: [
-          {
-            path: [`$.${attr}`, `$['${attr}']`],
-            filter: { type: attr.startsWith("age_over") ? "boolean" : "string" }
-          }
-        ]
-      }
-    }))
-  };
-  const params = new URLSearchParams({
-    response_type: "vp_token",
-    response_mode: "direct_post",
-    response_uri: input.responseUri,
-    client_id: input.clientId,
-    nonce: input.nonce,
-    state,
-    presentation_definition: JSON.stringify(presentationDefinition)
-  });
-  return {
-    uri: `openid4vp://authorize?${params.toString()}`,
-    presentationDefinition,
-    nonce: input.nonce,
-    state
-  };
-}
 
 // src/presentation.ts
 var parsers = [new SdJwtParser(), new MdocParser()];
@@ -492,10 +913,69 @@ async function parsePresentation(vpToken, options) {
     error: "Unsupported credential format"
   };
 }
+var INTERNAL_TO_DCQL_FORMAT = {
+  "sd-jwt-vc": "dc+sd-jwt",
+  mdoc: "mso_mdoc"
+};
+function classifyMismatch(query, decoded, hasDetail) {
+  if (decoded.format !== query.format) return "format_mismatch";
+  if (query.format === "dc+sd-jwt") {
+    const allowed = query.meta?.vct_values;
+    if (allowed && allowed.length > 0 && !allowed.includes(decoded.vct ?? "")) {
+      return "vct_mismatch";
+    }
+  }
+  if (query.format === "mso_mdoc") {
+    const expected = query.meta?.doctype_value;
+    if (expected && expected !== decoded.doctype) return "doctype_mismatch";
+  }
+  if (query.trusted_authorities && query.trusted_authorities.length > 0) {
+    const decodedAuthIds = decoded.trusted_authority_ids ?? [];
+    const anyMatch = query.trusted_authorities.some(
+      (ta) => ta.values.some((v) => decodedAuthIds.includes(v))
+    );
+    if (!anyMatch) return "trusted_authority_mismatch";
+  }
+  if (hasDetail) return "missing_claims";
+  return "no_credential_found";
+}
+function refineUnmatched(query, decoded, match) {
+  if (match.unmatched.length === 0) return match;
+  const refined = match.unmatched.map((entry) => {
+    const credentialQuery = query.credentials.find((c) => c.id === entry.queryId);
+    if (!credentialQuery) return entry;
+    const specific = classifyMismatch(credentialQuery, decoded, entry.detail !== void 0);
+    return { ...entry, reason: specific };
+  });
+  return { ...match, unmatched: refined };
+}
+async function verifyPresentation(vpToken, query, options) {
+  const parsed = await parsePresentation(vpToken, options);
+  const dcqlFormat = INTERNAL_TO_DCQL_FORMAT[parsed.format] ?? parsed.format;
+  const decodedClaims = parsed.format === "mdoc" && parsed.namespacedClaims !== void 0 ? parsed.namespacedClaims : parsed.claims;
+  const decoded = {
+    id: query.credentials[0]?.id ?? "presented",
+    format: dcqlFormat,
+    claims: decodedClaims
+  };
+  if (parsed.format === "sd-jwt-vc" && typeof parsed.vct === "string") {
+    decoded.vct = parsed.vct;
+  }
+  if (parsed.format === "mdoc" && typeof parsed.docType === "string") {
+    decoded.doctype = parsed.docType;
+  }
+  const rawMatch = matchQuery(query, [decoded]);
+  const match = refineUnmatched(query, decoded, rawMatch);
+  const submission = match.satisfied ? buildSubmission(query, match) : null;
+  return {
+    parsed,
+    match,
+    submission,
+    valid: parsed.valid && match.satisfied
+  };
+}
+var VERSION = "0.4.0";
 
-// src/index.ts
-var VERSION = "0.2.1";
-
-export { ExpiredCredentialError, InvalidSignatureError, MalformedCredentialError, MdocParser, NonceValidationError, SdJwtParser, UnsupportedFormatError, VERSION, createAuthorizationRequest, parsePresentation };
+export { ExpiredCredentialError, HAIP_DOCTYPE_NAMESPACES, HaipValidationError, InvalidSignatureError, MalformedCredentialError, MdocParser, NonceValidationError, SdJwtParser, UnsupportedFormatError, VERSION, buildHaipQuery, createAuthorizationRequest, isHaipQuery, parsePresentation, validateHaipQuery, verifyPresentation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map