@openeudi/openid4vp 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { splitSdJwt, decodeSdJwt, getClaims } from '@sd-jwt/decode';
 import { decodeProtectedHeader, importX509, jwtVerify, importJWK } from 'jose';
-import { decode } from 'cbor-x';
+import { Encoder, Tag } from 'cbor-x';
 import { v4 } from 'uuid';
 
 // src/parsers/sd-jwt.parser.ts
@@ -45,8 +45,8 @@ var NonceValidationError = class extends Error {
 // src/parsers/sd-jwt.parser.ts
 var DEFAULT_ALLOWED_ALGORITHMS = ["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);
 };
@@ -263,8 +263,111 @@ var SdJwtParser = class {
     };
   }
 };
-function isBinaryData(value) {
-  return value instanceof Uint8Array;
+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 bytesEqual2(a, b) {
   if (a.length !== b.length) return false;
@@ -273,96 +376,231 @@ function bytesEqual2(a, b) {
   }
   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;
+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 (!bytesEqual2(hash, expectedDigest)) {
+        throw new MalformedCredentialError(`digest mismatch for ns=${ns} digestID=${digestID}`);
       }
-    } 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);
+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);
     }
-  } 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);
+    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);
   }
-  return null;
+  throw new MalformedCredentialError(`unsupported date encoding in MSO: ${typeof value}`);
 }
-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;
+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");
   }
-  return claims;
+  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 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
-        };
+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_ALGORITHMS2 = ["ES256", "ES384", "ES512"];
+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 derToPem2(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 out = {};
+  for (const items of nameSpaces.values()) {
+    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") {
+          out[id] = val;
+        }
       }
     }
-  } catch {
   }
-  return {};
+  return out;
 }
 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 isBinaryData(vpToken);
+    return vpToken instanceof Uint8Array;
   }
   /**
    * Parses and validates an mDOC DeviceResponse token.
@@ -371,38 +609,49 @@ var MdocParser = class {
    *   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");
+    if (!(vpToken instanceof Uint8Array)) {
+      throw new MalformedCredentialError("mDOC vpToken must be a Uint8Array");
     }
-    const invalidResult = (error) => ({
-      valid: false,
-      format: this.format,
-      claims: {},
-      issuer: { certificate: new Uint8Array(), country: "" },
-      error
-    });
+    const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS2;
     let deviceResponse;
     try {
-      deviceResponse = decode(vpToken);
+      const decoded = decoder4.decode(vpToken);
+      if (!(decoded instanceof Map)) throw new Error();
+      deviceResponse = decoded;
     } catch {
-      throw new MalformedCredentialError("Failed to decode CBOR DeviceResponse");
+      throw new MalformedCredentialError("vpToken is not a CBOR DeviceResponse Map");
     }
-    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 docs = deviceResponse.get("documents");
+    if (!Array.isArray(docs) || docs.length === 0) {
+      throw new MalformedCredentialError("DeviceResponse has no documents");
     }
-    const document = deviceResponse.documents[0];
-    if (!document.issuerSigned || !document.issuerSigned.nameSpaces || !document.issuerSigned.issuerAuth) {
-      throw new MalformedCredentialError("Invalid mDOC document: missing issuerSigned data");
+    const document = docs[0];
+    if (!(document instanceof Map)) {
+      throw new MalformedCredentialError("document must be a Map");
     }
-    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 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");
     }
-    const issuerCertBytes = extractCertificateFromIssuerAuth(issuerAuth);
-    const issuerInfo = {
-      certificate: issuerCertBytes,
-      country: ""
-    };
     if (options.trustedCertificates.length === 0) {
       if (options.skipTrustCheck !== true) {
         throw new MalformedCredentialError(
@@ -410,31 +659,81 @@ var MdocParser = class {
         );
       }
     } else {
-      const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual2(trusted, issuerCertBytes));
-      if (!isTrusted) {
-        return invalidResult("Issuer certificate is not trusted");
+      const trusted = options.trustedCertificates.some((t) => bytesEqual3(t, issuerCertBytes));
+      if (!trusted) {
+        return {
+          valid: false,
+          format: this.format,
+          claims: {},
+          issuer: { certificate: issuerCertBytes, country: "" },
+          error: "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 publicKey = await importX509(derToPem2(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 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;
+    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;
     }
-    return {
-      valid: true,
-      format: this.format,
-      claims,
-      issuer: issuerInfo
+    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 claims = mapRawToClaims(nameSpaces);
+    const issuer = {
+      certificate: issuerCertBytes,
+      country: extractCountryHintFromCert()
     };
+    return { valid: true, format: this.format, claims, issuer };
   }
 };
 function createAuthorizationRequest(input) {
@@ -494,7 +793,7 @@ async function parsePresentation(vpToken, options) {
 }
 
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.3.0";
 
 export { ExpiredCredentialError, InvalidSignatureError, MalformedCredentialError, MdocParser, NonceValidationError, SdJwtParser, UnsupportedFormatError, VERSION, createAuthorizationRequest, parsePresentation };
 //# sourceMappingURL=index.js.map