@ixo/credentials-kit 0.0.0-stage → 0.1.1

package/dist/chunk-2SF56NEJ.js

@@ -0,0 +1,1053 @@
+import { REQUEST_OBJECT_TYP, CLIENT_ID_PREFIX } from './chunk-I6GBYFIJ.js';
+import { verifyPresentation } from './chunk-STMMFNVW.js';
+import { parseSdJwt, SdJwtError, selectDisclosures, serializeSdJwt, sdHash, processDisclosures } from './chunk-XREZY53L.js';
+import { didFromKid, ResolverUnavailable, findKey } from './chunk-WIEGZFUO.js';
+import { isFetchableUrl, request } from './chunk-Q3MZNMCK.js';
+import { CredentialsKitError, isRecord, toSeconds, clockMs, signJws, decodeJws, verifyEd25519, isEd25519JwsAlg, CLOCK_SKEW_S } from './chunk-VXKONZK4.js';
+import { randomToken, utf8, base64urlDecode, concatBytes, fromUtf8, base64urlEncode } from './chunk-AQ3IINHC.js';
+
+// src/internal/jwe.ts
+var JWE_ALG = "ECDH-ES";
+var JWE_ENCS = ["A256GCM", "A128GCM"];
+var JWE_ENC = "A256GCM";
+function isJweEnc(v) {
+  return v === "A256GCM" || v === "A128GCM";
+}
+function keyBitsOf(enc) {
+  return enc === "A128GCM" ? 128 : 256;
+}
+var MAX_JWE_LENGTH = 256 * 1024;
+var JweError = class extends Error {
+  constructor(kind) {
+    super(`JWE ${kind}`);
+    this.kind = kind;
+    this.name = "JweError";
+  }
+  kind;
+};
+function uint32be(n) {
+  const out = new Uint8Array(4);
+  new DataView(out.buffer).setUint32(0, n, false);
+  return out;
+}
+function lengthPrefixed(bytes) {
+  return concatBytes(uint32be(bytes.length), bytes);
+}
+async function concatKdf(z, keyBits, algorithmId, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+  const otherInfo = concatBytes(
+    lengthPrefixed(utf8(algorithmId)),
+    lengthPrefixed(apu),
+    lengthPrefixed(apv),
+    uint32be(keyBits)
+  );
+  const rounds = Math.ceil(keyBits / 256);
+  const parts = [];
+  for (let i = 1; i <= rounds; i++) {
+    const input = concatBytes(uint32be(i), z, otherInfo);
+    parts.push(new Uint8Array(await crypto.subtle.digest("SHA-256", input)));
+  }
+  return concatBytes(...parts).slice(0, keyBits / 8);
+}
+function isP256PublicJwk(v) {
+  return isRecord(v) && v.kty === "EC" && v.crv === "P-256" && typeof v.x === "string" && typeof v.y === "string" && !("d" in v);
+}
+function publicPart(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y };
+}
+async function importPublic(jwk) {
+  try {
+    return await crypto.subtle.importKey(
+      "jwk",
+      publicPart(jwk),
+      { name: "ECDH", namedCurve: "P-256" },
+      true,
+      []
+    );
+  } catch {
+    throw new JweError("bad_key");
+  }
+}
+async function importPrivate(jwk) {
+  try {
+    return await crypto.subtle.importKey(
+      "jwk",
+      { ...publicPart(jwk), d: jwk.d },
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      ["deriveBits"]
+    );
+  } catch {
+    throw new JweError("bad_key");
+  }
+}
+async function sharedSecret(priv, pub) {
+  return new Uint8Array(
+    await crypto.subtle.deriveBits({ name: "ECDH", public: pub }, priv, 256)
+  );
+}
+async function generateP256KeyPair(kid) {
+  const pair = await crypto.subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveBits"]
+  );
+  const priv = await crypto.subtle.exportKey("jwk", pair.privateKey);
+  if (!priv.x || !priv.y || !priv.d) throw new JweError("bad_key");
+  const publicJwk = {
+    kty: "EC",
+    crv: "P-256",
+    x: priv.x,
+    y: priv.y,
+    kid,
+    use: "enc",
+    alg: "ECDH-ES"
+  };
+  return { publicJwk, privateJwk: { ...publicJwk, d: priv.d } };
+}
+async function encryptJwe(payload, recipient, enc = JWE_ENC) {
+  if (!isJweEnc(enc)) throw new JweError("unsupported");
+  const recipientKey = await importPublic(recipient);
+  const eph = await crypto.subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveBits"]
+  );
+  const epk = await crypto.subtle.exportKey("jwk", eph.publicKey);
+  const header = {
+    alg: JWE_ALG,
+    enc,
+    ...recipient.kid !== void 0 ? { kid: recipient.kid } : {},
+    epk: { kty: "EC", crv: "P-256", x: epk.x, y: epk.y }
+  };
+  const z = await sharedSecret(eph.privateKey, recipientKey);
+  const cek = await concatKdf(z, keyBitsOf(enc), enc);
+  const protectedHeader = base64urlEncode(utf8(JSON.stringify(header)));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, [
+    "encrypt"
+  ]);
+  const sealed = new Uint8Array(
+    await crypto.subtle.encrypt(
+      {
+        name: "AES-GCM",
+        iv,
+        additionalData: utf8(protectedHeader),
+        tagLength: 128
+      },
+      key,
+      utf8(JSON.stringify(payload))
+    )
+  );
+  const ciphertext = sealed.slice(0, sealed.length - 16);
+  const tag = sealed.slice(sealed.length - 16);
+  return [
+    protectedHeader,
+    "",
+    base64urlEncode(iv),
+    base64urlEncode(ciphertext),
+    base64urlEncode(tag)
+  ].join(".");
+}
+function decodeJweHeader(compact) {
+  const first = compact.split(".")[0] ?? "";
+  try {
+    const header = JSON.parse(fromUtf8(base64urlDecode(first)));
+    if (!isRecord(header)) throw new JweError("malformed");
+    return header;
+  } catch {
+    throw new JweError("malformed");
+  }
+}
+async function decryptJwe(compact, recipient, accept = JWE_ENCS) {
+  if (typeof compact !== "string" || compact.length > MAX_JWE_LENGTH) {
+    throw new JweError("malformed");
+  }
+  const parts = compact.split(".");
+  if (parts.length !== 5) throw new JweError("malformed");
+  const [h, encryptedKey, ivB64, ctB64, tagB64] = parts;
+  if (encryptedKey !== "") throw new JweError("unsupported");
+  const header = decodeJweHeader(compact);
+  const enc = header.enc;
+  if (header.alg !== JWE_ALG || !isJweEnc(enc) || !accept.includes(enc)) {
+    throw new JweError("unsupported");
+  }
+  if (header.zip !== void 0 || header.crit !== void 0) {
+    throw new JweError("unsupported");
+  }
+  if (recipient.kid !== void 0 && header.kid !== void 0 && header.kid !== recipient.kid) {
+    throw new JweError("bad_key");
+  }
+  if (!isP256PublicJwk(header.epk)) throw new JweError("malformed");
+  let iv;
+  let ciphertext;
+  let tag;
+  let apu;
+  let apv;
+  try {
+    iv = base64urlDecode(ivB64);
+    ciphertext = base64urlDecode(ctB64);
+    tag = base64urlDecode(tagB64);
+    apu = typeof header.apu === "string" ? base64urlDecode(header.apu) : new Uint8Array(0);
+    apv = typeof header.apv === "string" ? base64urlDecode(header.apv) : new Uint8Array(0);
+  } catch {
+    throw new JweError("malformed");
+  }
+  if (iv.length !== 12 || tag.length !== 16) throw new JweError("malformed");
+  const epk = await importPublic(header.epk);
+  const priv = await importPrivate(recipient);
+  const z = await sharedSecret(priv, epk);
+  const cek = await concatKdf(z, keyBitsOf(enc), enc, apu, apv);
+  const key = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, [
+    "decrypt"
+  ]);
+  let plain;
+  try {
+    plain = new Uint8Array(
+      await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv, additionalData: utf8(h), tagLength: 128 },
+        key,
+        concatBytes(ciphertext, tag)
+      )
+    );
+  } catch {
+    throw new JweError("decrypt_failed");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(fromUtf8(plain));
+  } catch {
+    throw new JweError("malformed");
+  }
+  if (!isRecord(payload)) throw new JweError("malformed");
+  return payload;
+}
+
+// src/oid4vp.ts
+var SELF_ISSUED_AUDIENCE = "https://self-issued.me/v2";
+var RESPONSE_ENCRYPTION_ENC = "A256GCM";
+var RESPONSE_ENCRYPTION_ENCS = JWE_ENCS;
+var DEFAULT_RESPONSE_ENCRYPTION_ENC = "A128GCM";
+var MAX_CREDENTIAL_QUERIES = 16;
+var MAX_CLAIMS_PER_QUERY = 64;
+var MAX_REQUEST_OBJECT_LENGTH = 64 * 1024;
+var MAX_RESPONSE_BODY_LENGTH = 256 * 1024;
+var MAX_REQUEST_LIFETIME_SECONDS = 24 * 3600;
+var OID4VP_MESSAGES = {
+  malformed_request: "The presentation request is not well formed.",
+  wrong_type: "The request object is not typed oauth-authz-req+jwt.",
+  unsupported_client_id: "The request does not use a decentralized_identifier client_id.",
+  unknown_verifier: "The verifier's DID could not be found.",
+  unknown_key: "The request is not signed with a key of the verifier's DID.",
+  bad_signature: "The request signature does not verify.",
+  expired: "The request has expired.",
+  unsupported_request: "The request uses a feature this profile does not support.",
+  unsupported_response_mode: "The response mode is not direct_post or direct_post.jwt.",
+  insecure_response_uri: "The response URI is not an https address on the public internet.",
+  unsupported_query: "The DCQL query uses a feature this profile does not support.",
+  unsupported_encryption: "The response encryption parameters are not supported.",
+  malformed_response: "The presentation response is not well formed.",
+  decryption_failed: "The presentation response could not be decrypted.",
+  wallet_error: "The wallet answered with an error.",
+  state_mismatch: "The response state does not match the request."
+};
+var Oid4vpError = class extends CredentialsKitError {
+  /** For `wallet_error`: the OAuth error code the wallet sent (e.g. `access_denied`). */
+  walletError;
+  /**
+   * For `unsupported_request`: the feature refused (`credential_sets`, `claim_sets`,
+   * `trusted_authorities`, `nested_path`, `format`, `registered_claim`, `transaction_data`,
+   * `scope`, `response_type`, `request_uri_method`, `request`, `too_many_queries`,
+   * `too_many_claims`).
+   */
+  feature;
+  /**
+   * Set only when the request object's signature verified and its response URI is usable: the
+   * wallet may tell the verifier with `sendAuthorizationError({ target: error.errorTarget, … })`
+   * (OpenID4VP §8.5). Never set for a request that did not verify.
+   */
+  errorTarget;
+  constructor(code, walletError, extra = {}) {
+    super(code, OID4VP_MESSAGES[code]);
+    if (walletError !== void 0) this.walletError = walletError;
+    if (extra.feature !== void 0) this.feature = extra.feature;
+    if (extra.errorTarget !== void 0) this.errorTarget = extra.errorTarget;
+  }
+};
+function unsupported(feature) {
+  throw new Oid4vpError("unsupported_request", void 0, { feature });
+}
+function malformed() {
+  throw new Oid4vpError("malformed_request");
+}
+var QUERY_ID = /^[A-Za-z0-9_-]+$/;
+var STRUCTURAL_NAMES = /* @__PURE__ */ new Set(["_sd", "_sd_alg", "..."]);
+var NOT_REQUESTABLE = /* @__PURE__ */ new Set([
+  "nbf",
+  "exp",
+  "vct",
+  "vct#integrity",
+  "aka_vcts",
+  "cnf",
+  "status"
+]);
+function isPathElement(x) {
+  return typeof x === "string" || x === null || typeof x === "number" && Number.isSafeInteger(x) && x >= 0;
+}
+function validateClaim(v) {
+  if (!isRecord(v)) malformed();
+  if (v.id !== void 0 && (typeof v.id !== "string" || !QUERY_ID.test(v.id)))
+    malformed();
+  const path = v.path;
+  if (!Array.isArray(path) || path.length === 0 || !path.every(isPathElement))
+    malformed();
+  if (path.length !== 1 || typeof path[0] !== "string")
+    unsupported("nested_path");
+  const name = path[0];
+  if (name.length === 0 || STRUCTURAL_NAMES.has(name)) malformed();
+  if (NOT_REQUESTABLE.has(name)) unsupported("registered_claim");
+  let values;
+  if (v.values !== void 0) {
+    if (!Array.isArray(v.values) || v.values.length === 0) malformed();
+    for (const x of v.values) {
+      const ok = typeof x === "string" || typeof x === "boolean" || typeof x === "number" && Number.isInteger(x);
+      if (!ok) malformed();
+    }
+    values = v.values;
+  }
+  if (name === "iss" && values && !values.every((x) => typeof x === "string"))
+    malformed();
+  return {
+    ...typeof v.id === "string" ? { id: v.id } : {},
+    path: [name],
+    ...values ? { values } : {}
+  };
+}
+function validateCredentialQuery(v) {
+  if (!isRecord(v)) malformed();
+  if (typeof v.id !== "string" || !QUERY_ID.test(v.id)) malformed();
+  if (typeof v.format !== "string") malformed();
+  if (v.multiple !== void 0 && typeof v.multiple !== "boolean") malformed();
+  if (v.require_cryptographic_holder_binding !== void 0 && typeof v.require_cryptographic_holder_binding !== "boolean")
+    malformed();
+  const meta = v.meta;
+  if (v.format !== "dc+sd-jwt") unsupported("format");
+  if (!isRecord(meta) || !Array.isArray(meta.vct_values) || meta.vct_values.length === 0 || !meta.vct_values.every((x) => typeof x === "string" && x.length > 0)) {
+    malformed();
+  }
+  if (v.claim_sets !== void 0) unsupported("claim_sets");
+  if (v.trusted_authorities !== void 0) unsupported("trusted_authorities");
+  let claims;
+  if (v.claims !== void 0) {
+    if (!Array.isArray(v.claims) || v.claims.length === 0) malformed();
+    if (v.claims.length > MAX_CLAIMS_PER_QUERY) unsupported("too_many_claims");
+    const seen = /* @__PURE__ */ new Set();
+    claims = [];
+    for (const raw of v.claims) {
+      const claim = validateClaim(raw);
+      if (seen.has(claim.path[0])) continue;
+      seen.add(claim.path[0]);
+      claims.push(claim);
+    }
+  }
+  return {
+    id: v.id,
+    format: "dc+sd-jwt",
+    meta: { vct_values: [...meta.vct_values] },
+    ...claims ? { claims } : {},
+    ...typeof v.require_cryptographic_holder_binding === "boolean" ? {
+      require_cryptographic_holder_binding: v.require_cryptographic_holder_binding
+    } : {},
+    ...typeof v.multiple === "boolean" ? { multiple: v.multiple } : {}
+  };
+}
+function validateDcql(dcql) {
+  if (!isRecord(dcql)) malformed();
+  const creds = dcql.credentials;
+  if (!Array.isArray(creds) || creds.length === 0) malformed();
+  if (creds.length > MAX_CREDENTIAL_QUERIES) unsupported("too_many_queries");
+  const credentials = creds.map(validateCredentialQuery);
+  const ids = credentials.map((c) => c.id);
+  if (new Set(ids).size !== ids.length) malformed();
+  if (dcql.credential_sets !== void 0) unsupported("credential_sets");
+  return { credentials };
+}
+function issuerFilter(query) {
+  const iss = query.claims?.find((c) => c.path[0] === "iss");
+  return iss?.values;
+}
+function requestedClaims(query) {
+  return (query.claims ?? []).filter((c) => c.path[0] !== "iss");
+}
+function summarizeDcql(dcql) {
+  return validateDcql(dcql).credentials.map((q) => {
+    const issuers = issuerFilter(q);
+    return {
+      id: q.id,
+      vctValues: [...q.meta.vct_values],
+      claims: requestedClaims(q).map((c) => c.path[0]),
+      ...issuers ? { issuers: [...issuers] } : {}
+    };
+  });
+}
+function valueMatches(value, values) {
+  return values === void 0 || values.some((v) => v === value);
+}
+function matchCredential(query, parsed) {
+  let q;
+  try {
+    q = validateCredentialQuery(query);
+  } catch {
+    return { ok: false, reason: "unsupported_query" };
+  }
+  const typ = parsed.header.typ;
+  if (typ !== "dc+sd-jwt" && typ !== "vc+sd-jwt")
+    return { ok: false, reason: "wrong_format" };
+  const { payload } = parsed;
+  if (typeof payload.vct !== "string" || !q.meta.vct_values.includes(payload.vct)) {
+    return { ok: false, reason: "wrong_type" };
+  }
+  const issuers = issuerFilter(q);
+  if (issuers && (typeof payload.iss !== "string" || !issuers.includes(payload.iss))) {
+    return { ok: false, reason: "untrusted_issuer" };
+  }
+  const cnf = payload.cnf;
+  if (!isRecord(cnf) || !isRecord(cnf.jwk))
+    return { ok: false, reason: "no_holder_binding" };
+  const topDigests = new Set(
+    Array.isArray(payload._sd) ? payload._sd : []
+  );
+  const byName = new Map(
+    parsed.disclosures.filter((d) => d.name !== null && topDigests.has(d.digest)).map((d) => [d.name, d])
+  );
+  const disclose = [];
+  for (const claim of requestedClaims(q)) {
+    const name = claim.path[0];
+    const sd = byName.get(name);
+    if (sd) {
+      if (!valueMatches(sd.value, claim.values))
+        return { ok: false, reason: "value_mismatch" };
+      disclose.push(name);
+    } else if (Object.hasOwn(payload, name)) {
+      if (!valueMatches(payload[name], claim.values)) {
+        return { ok: false, reason: "value_mismatch" };
+      }
+    } else {
+      return { ok: false, reason: "missing_claim" };
+    }
+  }
+  return { ok: true, disclose };
+}
+function generateResponseKeyPair() {
+  return generateP256KeyPair(`enc-${randomToken(9)}`);
+}
+var URL_SAFE = /^[A-Za-z0-9._~-]+$/;
+async function createAuthorizationRequest(input) {
+  if (didFromKid(input.signer.kid) !== input.clientDid || !input.signer.kid.includes("#")) {
+    throw new Oid4vpError("unknown_key");
+  }
+  if (!isFetchableUrl(input.responseUri, {
+    allowHttp: input.allowHttp ?? false,
+    allowLocal: input.allowLocal ?? false
+  })) {
+    throw new Oid4vpError("insecure_response_uri");
+  }
+  if (!URL_SAFE.test(input.nonce) || input.nonce.length < 16) malformed();
+  if (typeof input.state !== "string" || !URL_SAFE.test(input.state))
+    malformed();
+  const dcql = validateDcql(input.dcql);
+  const iat = toSeconds(clockMs(input.now));
+  if (!Number.isSafeInteger(input.exp) || input.exp <= iat) malformed();
+  const enc = input.responseEncryptionJwk;
+  if (enc !== void 0 && (!isP256PublicJwk(enc) || typeof enc.kid !== "string")) {
+    throw new Oid4vpError("unsupported_encryption");
+  }
+  const clientMetadata = {
+    vp_formats_supported: {
+      "dc+sd-jwt": {
+        // Fully-specified name first (RFC 9864), then the JWS name most wallets still match.
+        "sd-jwt_alg_values": ["Ed25519", "EdDSA"],
+        "kb-jwt_alg_values": ["Ed25519", "EdDSA"]
+      }
+    },
+    ...enc ? {
+      jwks: { keys: [{ ...enc, use: "enc", alg: "ECDH-ES" }] },
+      encrypted_response_enc_values_supported: [
+        ...RESPONSE_ENCRYPTION_ENCS
+      ]
+    } : {}
+  };
+  return signJws(
+    { alg: "EdDSA", typ: REQUEST_OBJECT_TYP, kid: input.signer.kid },
+    {
+      aud: SELF_ISSUED_AUDIENCE,
+      client_id: `${CLIENT_ID_PREFIX}${input.clientDid}`,
+      response_type: "vp_token",
+      response_mode: enc ? "direct_post.jwt" : "direct_post",
+      response_uri: input.responseUri,
+      nonce: input.nonce,
+      state: input.state,
+      dcql_query: dcql,
+      client_metadata: clientMetadata,
+      iat,
+      exp: input.exp
+    },
+    input.signer
+  );
+}
+var MAX_WALLET_LINK_LENGTH = 4096;
+function buildWalletLink(input) {
+  const scheme = input.scheme ?? "openid4vp://";
+  if (typeof input.clientId !== "string" || input.clientId.length === 0)
+    throw new TypeError("clientId is required");
+  let requestUri;
+  try {
+    requestUri = new URL(input.requestUri);
+  } catch {
+    throw new TypeError("requestUri must be an absolute URL");
+  }
+  if (requestUri.protocol !== "https:" && requestUri.protocol !== "http:")
+    throw new TypeError("requestUri must be an http(s) URL");
+  let base;
+  if (/^[a-z][a-z0-9+.-]*:(?:\/\/)?$/i.test(scheme)) {
+    const name = scheme.slice(0, scheme.indexOf(":")).toLowerCase();
+    if (["javascript", "data", "vbscript", "file", "blob", "http"].includes(name))
+      throw new TypeError("scheme must be a custom scheme or an https URL");
+    base = scheme;
+  } else {
+    let u;
+    try {
+      u = new URL(scheme);
+    } catch {
+      throw new TypeError("scheme must be a custom scheme or an https URL");
+    }
+    if (u.protocol !== "https:" || u.search || u.hash)
+      throw new TypeError("scheme must be a custom scheme or an https URL");
+    base = u.href;
+  }
+  const params = new URLSearchParams({
+    client_id: input.clientId,
+    request_uri: input.requestUri
+  });
+  return `${base}?${params.toString()}`;
+}
+function parseWalletLink(link, opts = {}) {
+  if (typeof link !== "string" || link.length > MAX_WALLET_LINK_LENGTH)
+    malformed();
+  const q = link.indexOf("?");
+  if (q < 0) malformed();
+  const query = link.slice(q + 1).split("#")[0] ?? "";
+  const params = new URLSearchParams(query);
+  if (params.has("request")) unsupported("request");
+  const method = params.getAll("request_uri_method");
+  if (method.length > 1 || method.length === 1 && method[0] !== "get") {
+    if (method[0] === "post") unsupported("request_uri_method");
+    malformed();
+  }
+  const clientIds = params.getAll("client_id");
+  const requestUris = params.getAll("request_uri");
+  if (clientIds.length !== 1 || requestUris.length !== 1) malformed();
+  const clientId = clientIds[0];
+  const requestUri = requestUris[0];
+  if (clientId.length === 0) malformed();
+  if (!isFetchableUrl(requestUri, {
+    allowHttp: opts.allowHttp ?? false,
+    allowLocal: opts.allowLocal ?? false
+  }))
+    malformed();
+  return { clientId, requestUri };
+}
+function checkHeader(header, payload, expectedClientId) {
+  if (header.typ !== REQUEST_OBJECT_TYP) throw new Oid4vpError("wrong_type");
+  if (!isEd25519JwsAlg(header.alg)) throw new Oid4vpError("bad_signature");
+  const clientId = payload.client_id;
+  if (typeof clientId !== "string" || !clientId.startsWith(CLIENT_ID_PREFIX)) {
+    throw new Oid4vpError("unsupported_client_id");
+  }
+  if (expectedClientId !== void 0 && clientId !== expectedClientId)
+    malformed();
+  const clientDid = clientId.slice(CLIENT_ID_PREFIX.length);
+  if (!/^did:[a-z0-9]+:\S+$/.test(clientDid) || clientDid.includes("#")) {
+    throw new Oid4vpError("unsupported_client_id");
+  }
+  const kid = typeof header.kid === "string" ? header.kid : "";
+  const absoluteKid = kid.startsWith("#") ? `${clientDid}${kid}` : kid;
+  if (didFromKid(absoluteKid) !== clientDid || !absoluteKid.includes("#")) {
+    throw new Oid4vpError("unknown_key");
+  }
+  return { clientId, clientDid, kid: absoluteKid };
+}
+function checkTimes(payload, opts) {
+  const { exp, iat, aud } = payload;
+  if (exp !== void 0 && (typeof exp !== "number" || !Number.isFinite(exp)))
+    malformed();
+  if (iat !== void 0 && (typeof iat !== "number" || !Number.isFinite(iat)))
+    malformed();
+  if (exp === void 0 && opts.requireExpiry) malformed();
+  if (aud !== void 0 && aud !== SELF_ISSUED_AUDIENCE) malformed();
+  if (opts.nowS === null) return;
+  const nowS = opts.nowS;
+  if (typeof exp === "number" && nowS > exp + CLOCK_SKEW_S)
+    throw new Oid4vpError("expired");
+  if (typeof iat === "number" && iat > nowS + CLOCK_SKEW_S) malformed();
+  if (typeof exp === "number") {
+    const from = typeof iat === "number" ? iat : nowS;
+    if (exp - from > MAX_REQUEST_LIFETIME_SECONDS + CLOCK_SKEW_S) malformed();
+  }
+}
+function chooseEncryption(meta) {
+  if (!isRecord(meta)) return null;
+  const encsRaw = meta.encrypted_response_enc_values_supported;
+  const encs = encsRaw === void 0 ? [DEFAULT_RESPONSE_ENCRYPTION_ENC] : Array.isArray(encsRaw) ? encsRaw : [];
+  const enc = RESPONSE_ENCRYPTION_ENCS.find((e) => encs.includes(e));
+  const keys = isRecord(meta.jwks) ? meta.jwks.keys : void 0;
+  const key = Array.isArray(keys) ? keys.slice(0, 16).find(
+    (k) => isP256PublicJwk(k) && k.alg === "ECDH-ES" && (k.kid === void 0 || typeof k.kid === "string") && (k.use === void 0 || k.use === "enc")
+  ) : void 0;
+  if (!enc || !isJweEnc(enc) || !key) return null;
+  return {
+    jwk: {
+      kty: "EC",
+      crv: "P-256",
+      x: key.x,
+      y: key.y,
+      ...typeof key.kid === "string" ? { kid: key.kid } : {},
+      use: "enc",
+      alg: "ECDH-ES"
+    },
+    enc
+  };
+}
+function parsePayload(jwt, head, payload, opts) {
+  const mode = payload.response_mode;
+  if (mode !== "direct_post" && mode !== "direct_post.jwt") {
+    throw new Oid4vpError("unsupported_response_mode");
+  }
+  const responseUri = payload.response_uri;
+  if (typeof responseUri !== "string") malformed();
+  if (!isFetchableUrl(responseUri, {
+    allowHttp: opts.allowHttp ?? false,
+    allowLocal: opts.allowLocal ?? false
+  })) {
+    throw new Oid4vpError("insecure_response_uri");
+  }
+  const state = payload.state;
+  if (state !== void 0 && (typeof state !== "string" || !URL_SAFE.test(state)))
+    malformed();
+  const encryption = mode === "direct_post.jwt" ? chooseEncryption(payload.client_metadata) : null;
+  const target = {
+    clientId: head.clientId,
+    responseUri,
+    responseMode: mode,
+    ...state !== void 0 ? { state } : {},
+    ...encryption ? {
+      responseEncryptionJwk: encryption.jwk,
+      responseEncryptionEnc: encryption.enc
+    } : {}
+  };
+  const refuse = (code, feature) => new Oid4vpError(code, void 0, {
+    ...feature !== void 0 ? { feature } : {},
+    errorTarget: target
+  });
+  if (mode === "direct_post.jwt" && !encryption)
+    throw refuse("unsupported_encryption");
+  if (payload.redirect_uri !== void 0) throw refuse("malformed_request");
+  if (payload.response_type !== "vp_token")
+    throw refuse("unsupported_request", "response_type");
+  if (payload.transaction_data !== void 0)
+    throw refuse("unsupported_request", "transaction_data");
+  if (payload.scope !== void 0) throw refuse("unsupported_request", "scope");
+  const nonce = payload.nonce;
+  if (typeof nonce !== "string" || !URL_SAFE.test(nonce))
+    throw refuse("malformed_request");
+  let dcql;
+  try {
+    dcql = validateDcql(payload.dcql_query);
+  } catch (e) {
+    if (e instanceof Oid4vpError) throw refuse(e.code, e.feature);
+    throw e;
+  }
+  return {
+    jwt,
+    clientId: head.clientId,
+    clientDid: head.clientDid,
+    kid: head.kid,
+    responseUri,
+    responseMode: mode,
+    nonce,
+    ...state !== void 0 ? { state } : {},
+    dcql,
+    ...encryption ? {
+      responseEncryptionJwk: encryption.jwk,
+      responseEncryptionEnc: encryption.enc
+    } : {},
+    ...typeof payload.exp === "number" ? { exp: payload.exp } : {},
+    ...typeof payload.iat === "number" ? { iat: payload.iat } : {}
+  };
+}
+async function verifyAuthorizationRequest(jwt, opts) {
+  if (typeof jwt !== "string" || jwt.length > MAX_REQUEST_OBJECT_LENGTH) {
+    malformed();
+  }
+  let jws;
+  try {
+    jws = decodeJws(jwt.trim());
+  } catch {
+    malformed();
+  }
+  const parseOpts = {
+    allowHttp: opts.allowHttp ?? false,
+    allowLocal: opts.allowLocal ?? false,
+    nowS: toSeconds(clockMs(opts.now)),
+    requireExpiry: opts.requireExpiry ?? false
+  };
+  const head = checkHeader(jws.header, jws.payload, opts.expectedClientId);
+  checkTimes(jws.payload, parseOpts);
+  let doc;
+  try {
+    doc = await opts.resolver(head.clientDid);
+  } catch (e) {
+    if (e instanceof ResolverUnavailable) throw e;
+    throw new Oid4vpError("unknown_verifier");
+  }
+  if (!doc) throw new Oid4vpError("unknown_verifier");
+  const key = findKey(doc, head.kid, "authentication") ?? findKey(doc, head.kid, "assertionMethod");
+  if (!key) throw new Oid4vpError("unknown_key");
+  if (!verifyEd25519(jws.signature, utf8(jws.signingInput), key.publicKey)) {
+    throw new Oid4vpError("bad_signature");
+  }
+  return parsePayload(jwt.trim(), head, jws.payload, parseOpts);
+}
+function decodeOwnAuthorizationRequest(jwt, opts = {}) {
+  let jws;
+  try {
+    jws = decodeJws(jwt.trim());
+  } catch {
+    malformed();
+  }
+  const parseOpts = {
+    allowHttp: opts.allowHttp ?? false,
+    allowLocal: opts.allowLocal ?? false,
+    nowS: null,
+    requireExpiry: false
+  };
+  const head = checkHeader(jws.header, jws.payload, void 0);
+  checkTimes(jws.payload, parseOpts);
+  return parsePayload(jwt.trim(), head, jws.payload, parseOpts);
+}
+async function createPresentation(input) {
+  const parsed = parseSdJwt(input.sdjwt.trim());
+  if (parsed.kbJwt !== void 0) throw new SdJwtError("malformed");
+  const raws = selectDisclosures(parsed, input.disclose);
+  const base = serializeSdJwt(parsed.jwt, raws);
+  const kb = await signJws(
+    { alg: "EdDSA", typ: "kb+jwt" },
+    {
+      iat: toSeconds(clockMs(input.now)),
+      aud: input.audience,
+      nonce: input.nonce,
+      sd_hash: sdHash(base)
+    },
+    input.signer
+  );
+  return base + kb;
+}
+function checkVpToken(vpToken, dcql) {
+  if (!isRecord(vpToken)) throw new Oid4vpError("malformed_response");
+  const ids = dcql ? new Set(dcql.credentials.map((c) => c.id)) : null;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [id, list] of Object.entries(vpToken)) {
+    if (ids && !ids.has(id)) throw new Oid4vpError("malformed_response");
+    if (!Array.isArray(list) || list.length !== 1 || !list.every((p) => typeof p === "string" && p.length > 0)) {
+      throw new Oid4vpError("malformed_response");
+    }
+    out[id] = [...list];
+  }
+  if (Object.keys(out).length === 0)
+    throw new Oid4vpError("malformed_response");
+  return out;
+}
+async function formBody(target, members) {
+  const params = new URLSearchParams();
+  const withState = {
+    ...members,
+    ...target.state !== void 0 ? { state: target.state } : {}
+  };
+  if (target.responseMode === "direct_post.jwt" && target.responseEncryptionJwk) {
+    params.set(
+      "response",
+      await encryptJwe(
+        withState,
+        target.responseEncryptionJwk,
+        target.responseEncryptionEnc ?? DEFAULT_RESPONSE_ENCRYPTION_ENC
+      )
+    );
+  } else {
+    for (const [k, v] of Object.entries(withState))
+      params.set(k, typeof v === "string" ? v : JSON.stringify(v));
+  }
+  return params.toString();
+}
+async function createAuthorizationResponse(input) {
+  const { request: request2 } = input;
+  const vpToken = checkVpToken(input.vpToken, request2.dcql);
+  if (request2.responseMode === "direct_post.jwt" && !request2.responseEncryptionJwk)
+    throw new Oid4vpError("unsupported_encryption");
+  return {
+    url: request2.responseUri,
+    body: await formBody(request2, { vp_token: vpToken }),
+    contentType: "application/x-www-form-urlencoded"
+  };
+}
+var AUTHORIZATION_ERROR_CODES = /* @__PURE__ */ new Set([
+  "invalid_request",
+  "access_denied",
+  "invalid_client",
+  "invalid_scope",
+  "vp_formats_not_supported",
+  "invalid_request_uri_method",
+  "invalid_transaction_data",
+  "wallet_unavailable"
+]);
+var ERROR_DESCRIPTION = /^[\x20-\x21\x23-\x5b\x5d-\x7e]{1,300}$/;
+function authorizationErrorFor(e) {
+  if (!(e instanceof Oid4vpError) || !e.errorTarget) return null;
+  if (e.code === "unsupported_request") {
+    if (e.feature === "transaction_data") return "invalid_transaction_data";
+    if (e.feature === "format") return "vp_formats_not_supported";
+    if (e.feature === "scope") return "invalid_scope";
+  }
+  return "invalid_request";
+}
+async function createAuthorizationErrorResponse(input) {
+  if (!AUTHORIZATION_ERROR_CODES.has(input.error))
+    throw new TypeError("error is not an OpenID4VP error code");
+  if (input.errorDescription !== void 0 && !ERROR_DESCRIPTION.test(input.errorDescription))
+    throw new TypeError(
+      'errorDescription must be printable ASCII without " and \\ (at most 300)'
+    );
+  return {
+    url: input.target.responseUri,
+    body: await formBody(input.target, {
+      error: input.error,
+      ...input.errorDescription !== void 0 ? { error_description: input.errorDescription } : {}
+    }),
+    contentType: "application/x-www-form-urlencoded"
+  };
+}
+async function sendAuthorizationError(input) {
+  const policy = {
+    allowHttp: input.allowHttp ?? false,
+    allowLocal: input.allowLocal ?? false
+  };
+  if (!isFetchableUrl(input.target.responseUri, policy))
+    throw new Oid4vpError("insecure_response_uri");
+  const res = await createAuthorizationErrorResponse(input);
+  let answer;
+  try {
+    answer = await request(input.fetch, res.url, {
+      method: "POST",
+      headers: {
+        "content-type": res.contentType,
+        accept: "application/json"
+      },
+      body: res.body,
+      maxBytes: 16 * 1024,
+      ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+    });
+  } catch {
+    return { delivered: false, status: null };
+  }
+  let redirectUri;
+  if (answer.status === 200) {
+    try {
+      const json = JSON.parse(answer.text);
+      if (isRecord(json) && typeof json.redirect_uri === "string" && // A fragment is normal here (§8.2 example: `#response_code=…`).
+      isFetchableUrl(json.redirect_uri.split("#")[0] ?? "", policy))
+        redirectUri = json.redirect_uri;
+    } catch {
+    }
+  }
+  return {
+    delivered: answer.status === 200,
+    status: answer.status,
+    ...redirectUri !== void 0 ? { redirectUri } : {}
+  };
+}
+async function parseAuthorizationResponse(body, opts = {}) {
+  if (opts.request?.responseMode === "direct_post.jwt" && !opts.decryptionKey)
+    throw new TypeError(
+      "decryptionKey is required for a direct_post.jwt request"
+    );
+  if (typeof body === "string" && body.length > MAX_RESPONSE_BODY_LENGTH) {
+    throw new Oid4vpError("malformed_response");
+  }
+  const params = typeof body === "string" ? new URLSearchParams(body) : body;
+  const error = params.get("error");
+  if (error !== null) {
+    throw new Oid4vpError("wallet_error", walletErrorCode(error));
+  }
+  let vpToken;
+  let state;
+  const response = params.get("response");
+  if (opts.decryptionKey) {
+    if (response === null || params.has("vp_token")) {
+      throw new Oid4vpError("malformed_response");
+    }
+    let payload;
+    try {
+      payload = await decryptJwe(response, opts.decryptionKey);
+    } catch (e) {
+      if (e instanceof JweError && e.kind === "malformed") {
+        throw new Oid4vpError("malformed_response");
+      }
+      throw new Oid4vpError("decryption_failed");
+    }
+    if (typeof payload.error === "string") {
+      throw new Oid4vpError("wallet_error", walletErrorCode(payload.error));
+    }
+    vpToken = typeof payload.vp_token === "string" ? parseJson(payload.vp_token) : payload.vp_token;
+    state = payload.state;
+  } else {
+    if (response !== null) throw new Oid4vpError("decryption_failed");
+    const raw = params.get("vp_token");
+    if (raw === null) throw new Oid4vpError("malformed_response");
+    vpToken = parseJson(raw);
+    state = params.get("state") ?? void 0;
+  }
+  if (state !== void 0 && typeof state !== "string") {
+    throw new Oid4vpError("malformed_response");
+  }
+  return {
+    vpToken: checkVpToken(vpToken, null),
+    ...typeof state === "string" ? { state } : {}
+  };
+}
+function walletErrorCode(error) {
+  return /^[A-Za-z0-9_.-]{1,64}$/.test(error) ? error : "invalid";
+}
+function parseJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    throw new Oid4vpError("malformed_response");
+  }
+}
+async function verifyAuthorizationResponse(input) {
+  const request2 = typeof input.request === "string" ? (
+    // Your own request: its response URI was checked when you created it.
+    decodeOwnAuthorizationRequest(input.request, {
+      allowHttp: true,
+      allowLocal: true
+    })
+  ) : input.request;
+  if (input.state !== request2.state) {
+    throw new Oid4vpError("state_mismatch");
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  const unbound = (code) => ({
+    ok: false,
+    code,
+    holderAuthenticated: false,
+    keyBindingValid: false
+  });
+  let everySubjectExpected = true;
+  const queryIds = new Set(request2.dcql.credentials.map((q) => q.id));
+  for (const id of Object.keys(input.vpToken)) {
+    if (!queryIds.has(id)) results[id] = unbound("unexpected_presentation");
+  }
+  for (const query of request2.dcql.credentials) {
+    const policy = input.policyFor(query.id);
+    const subjectExpected = policy.expectedSubject !== void 0;
+    if (!subjectExpected) everySubjectExpected = false;
+    const list = input.vpToken[query.id];
+    if (list?.length !== 1 || typeof list[0] !== "string") {
+      results[query.id] = unbound("missing_presentation");
+      continue;
+    }
+    const presentation = list[0];
+    const out = await verifyPresentation(
+      presentation,
+      {
+        ...policy,
+        audience: request2.clientId,
+        nonce: request2.nonce,
+        requireKeyBinding: true
+      },
+      input.deps
+    );
+    if (!out.ok) {
+      results[query.id] = {
+        ok: false,
+        code: out.code,
+        holderAuthenticated: out.holderAuthenticated,
+        keyBindingValid: out.keyBindingValid
+      };
+      continue;
+    }
+    const failQuery = (code) => ({
+      ok: false,
+      code,
+      holderAuthenticated: subjectExpected,
+      keyBindingValid: true
+    });
+    if (!query.meta.vct_values.includes(out.vct)) {
+      results[query.id] = failQuery("wrong_type");
+      continue;
+    }
+    const issuers = issuerFilter(query);
+    if (issuers && !issuers.includes(out.issuer)) {
+      results[query.id] = failQuery("untrusted_issuer");
+      continue;
+    }
+    const visible = visibleClaims(out, presentation, requestedClaims(query));
+    let failure = null;
+    for (const claim of requestedClaims(query)) {
+      const name = claim.path[0];
+      if (!Object.hasOwn(visible, name)) {
+        failure = failQuery("missing_claim");
+        break;
+      }
+      if (!valueMatches(visible[name], claim.values)) {
+        failure = failQuery("value_mismatch");
+        break;
+      }
+    }
+    results[query.id] = failure ?? out;
+  }
+  const verifiedOnes = Object.values(results).filter(
+    (r) => r.ok
+  );
+  const first = verifiedOnes[0];
+  if (first && verifiedOnes.some(
+    (r) => r.subject !== first.subject || r.holderKey?.x !== first.holderKey?.x
+  )) {
+    for (const [id, r] of Object.entries(results)) {
+      if (r.ok) results[id] = unbound("wrong_subject");
+    }
+  }
+  const all = Object.values(results);
+  return {
+    ok: all.every((r) => r.ok),
+    results,
+    holderAuthenticated: everySubjectExpected && all.every((r) => r.ok || r.holderAuthenticated),
+    keyBindingValid: all.every((r) => r.ok || r.keyBindingValid)
+  };
+}
+var SIGNED_REGISTERED_CLAIMS = ["sub", "iat"];
+function visibleClaims(out, presentation, claims) {
+  const wanted = SIGNED_REGISTERED_CLAIMS.filter(
+    (name) => claims.some((c) => c.path[0] === name)
+  );
+  if (wanted.length === 0) return out.claims;
+  const visible = { ...out.claims, sub: out.subject };
+  if (wanted.includes("iat")) {
+    const parsed = parseSdJwt(presentation.trim());
+    const all = processDisclosures(parsed.payload, parsed.disclosures).claims;
+    if (typeof all.iat === "number") visible.iat = all.iat;
+  }
+  return visible;
+}
+
+export { DEFAULT_RESPONSE_ENCRYPTION_ENC, MAX_CLAIMS_PER_QUERY, MAX_CREDENTIAL_QUERIES, MAX_REQUEST_LIFETIME_SECONDS, MAX_REQUEST_OBJECT_LENGTH, MAX_RESPONSE_BODY_LENGTH, Oid4vpError, RESPONSE_ENCRYPTION_ENC, RESPONSE_ENCRYPTION_ENCS, SELF_ISSUED_AUDIENCE, authorizationErrorFor, buildWalletLink, createAuthorizationErrorResponse, createAuthorizationRequest, createAuthorizationResponse, createPresentation, decodeOwnAuthorizationRequest, generateResponseKeyPair, matchCredential, parseAuthorizationResponse, parseWalletLink, sendAuthorizationError, summarizeDcql, validateDcql, verifyAuthorizationRequest, verifyAuthorizationResponse };
+//# sourceMappingURL=chunk-2SF56NEJ.js.map
+//# sourceMappingURL=chunk-2SF56NEJ.js.map