@openid4vc/openid4vp 0.3.0-alpha-20250321202313 → 0.3.0-alpha-20250321205459

package/dist/index.js

@@ -885,7 +885,7 @@ function parseOpenid4vpAuthorizationRequest(options) {
 // src/authorization-request/resolve-authorization-request.ts
 var import_oauth219 = require("@openid4vc/oauth2");
 var import_utils14 = require("@openid4vc/utils");
-var import_zod14 = __toESM(require("zod"));
+var import_zod13 = __toESM(require("zod"));
 
 // src/fetch-client-metadata.ts
 var import_oauth213 = require("@openid4vc/oauth2");
@@ -982,22 +982,25 @@ function parseAuthorizationRequestVersion(request) {
 // src/jar/jar-request-object/fetch-jar-request-object.ts
 var import_oauth215 = require("@openid4vc/oauth2");
 var import_utils12 = require("@openid4vc/utils");
-var import_zod11 = require("zod");
 async function fetchJarRequestObject(options) {
-  const { requestUri, clientIdentifierScheme, method, wallet, fetch } = options;
-  const fetcher = (0, import_utils12.createZodFetcher)(fetch);
+  const { requestUri, clientIdentifierScheme, method, wallet, fetch = import_utils12.defaultFetcher } = options;
   let requestBody = wallet.metadata ? { wallet_metadata: wallet.metadata, wallet_nonce: wallet.nonce } : void 0;
   if (requestBody?.wallet_metadata?.request_object_signing_alg_values_supported && clientIdentifierScheme === "redirect_uri") {
     const { request_object_signing_alg_values_supported, ...rest } = requestBody.wallet_metadata;
     requestBody = { ...requestBody, wallet_metadata: { ...rest } };
   }
-  const { result, response } = await fetcher(import_zod11.z.string(), import_utils12.ContentType.OAuthAuthorizationRequestJwt, requestUri, {
+  const response = await fetch(requestUri, {
     method,
+    body: method === "POST" ? (0, import_utils12.objectToQueryParams)(wallet.metadata ?? {}) : void 0,
     headers: {
-      Accept: `${import_utils12.ContentType.OAuthAuthorizationRequestJwt}, ${import_utils12.ContentType.Jwt};q=0.9`,
+      Accept: `${import_utils12.ContentType.OAuthAuthorizationRequestJwt}, ${import_utils12.ContentType.Jwt};q=0.9, text/plain`,
       "Content-Type": import_utils12.ContentType.XWwwFormUrlencoded
-    },
-    body: method === "POST" ? (0, import_utils12.objectToQueryParams)(wallet.metadata ?? {}) : void 0
+    }
+  }).catch(() => {
+    throw new import_oauth215.Oauth2ServerErrorResponseError({
+      error_description: `Fetching request_object from request_uri '${requestUri}' failed`,
+      error: import_oauth215.Oauth2ErrorCodes.InvalidRequestUri
+    });
   });
   if (!response.ok) {
     throw new import_oauth215.Oauth2ServerErrorResponseError({
@@ -1005,21 +1008,15 @@ async function fetchJarRequestObject(options) {
       error: import_oauth215.Oauth2ErrorCodes.InvalidRequestUri
     });
   }
-  if (!result || !result.success) {
-    throw new import_oauth215.Oauth2ServerErrorResponseError({
-      error_description: `Parsing request_object from request_uri '${requestUri}' failed.`,
-      error: import_oauth215.Oauth2ErrorCodes.InvalidRequestObject
-    });
-  }
-  return result.data;
+  return await response.text();
 }
 
 // src/jar/jar-request-object/z-jar-request-object.ts
 var import_oauth216 = require("@openid4vc/oauth2");
-var import_zod12 = require("zod");
-var zJarRequestObjectPayload = import_zod12.z.object({
+var import_zod11 = require("zod");
+var zJarRequestObjectPayload = import_zod11.z.object({
   ...import_oauth216.zJwtPayload.shape,
-  client_id: import_zod12.z.string()
+  client_id: import_zod11.z.string()
 }).passthrough();
 
 // src/jar/handle-jar-request/verify-jar-request.ts
@@ -1123,13 +1120,13 @@ var import_oauth218 = require("@openid4vc/oauth2");
 var import_utils13 = require("@openid4vc/utils");
 
 // src/transaction-data/z-transaction-data.ts
-var import_zod13 = require("zod");
-var zTransactionEntry = import_zod13.z.object({
-  type: import_zod13.z.string(),
-  credential_ids: import_zod13.z.array(import_zod13.z.string()).nonempty(),
-  transaction_data_hashes_alg: import_zod13.z.array(import_zod13.z.string()).optional()
+var import_zod12 = require("zod");
+var zTransactionEntry = import_zod12.z.object({
+  type: import_zod12.z.string(),
+  credential_ids: import_zod12.z.array(import_zod12.z.string()).nonempty(),
+  transaction_data_hashes_alg: import_zod12.z.array(import_zod12.z.string()).optional()
 });
-var zTransactionData = import_zod13.z.array(zTransactionEntry);
+var zTransactionData = import_zod12.z.array(zTransactionEntry);
 
 // src/transaction-data/parse-transaction-data.ts
 function parseTransactionData(options) {
@@ -1154,7 +1151,7 @@ async function resolveOpenid4vpAuthorizationRequest(options) {
   const { wallet, callbacks, origin, disableOriginValidation } = options;
   let authorizationRequestPayload;
   const parsed = (0, import_utils14.parseWithErrorHandling)(
-    import_zod14.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest, zJarAuthorizationRequest]),
+    import_zod13.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest, zJarAuthorizationRequest]),
     options.authorizationRequestPayload,
     "Invalid authorization request. Could not parse openid4vp authorization request as openid4vp or jar auth request."
   );
@@ -1162,7 +1159,7 @@ async function resolveOpenid4vpAuthorizationRequest(options) {
   if (isJarAuthorizationRequest(parsed)) {
     jar = await verifyJarRequest({ jarRequestParams: parsed, callbacks, wallet });
     const parsedJarAuthorizationRequestPayload = (0, import_utils14.parseWithErrorHandling)(
-      import_zod14.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest]),
+      import_zod13.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest]),
       jar.authorizationRequestPayload,
       "Invalid authorization request. Could not parse jar request payload as openid4vp auth request."
     );
@@ -1276,7 +1273,7 @@ async function createJarmAuthorizationResponse(options) {
 }
 
 // src/jarm/jarm-response-mode.ts
-var import_zod15 = require("zod");
+var import_zod14 = require("zod");
 var jarmResponseMode = [
   "jwt",
   "query.jwt",
@@ -1285,7 +1282,7 @@ var jarmResponseMode = [
   "direct_post.jwt",
   "dc_api.jwt"
 ];
-var zJarmResponseMode = import_zod15.z.enum(jarmResponseMode);
+var zJarmResponseMode = import_zod14.z.enum(jarmResponseMode);
 var isJarmResponseMode = (responseMode) => {
   return jarmResponseMode.includes(responseMode);
 };
@@ -1483,17 +1480,17 @@ var import_oauth225 = require("@openid4vc/oauth2");
 var import_utils19 = require("@openid4vc/utils");
 
 // src/vp-token/z-vp-token.ts
-var import_zod16 = require("zod");
-var zVpTokenPexEntry = import_zod16.z.union([import_zod16.z.string(), import_zod16.z.record(import_zod16.z.any())], {
+var import_zod15 = require("zod");
+var zVpTokenPexEntry = import_zod15.z.union([import_zod15.z.string(), import_zod15.z.record(import_zod15.z.any())], {
   message: "pex vp_token entry must be a string or object"
 });
-var zVpTokenPex = import_zod16.z.union(
-  [zVpTokenPexEntry, import_zod16.z.array(zVpTokenPexEntry).nonempty("Must have at least entry in vp_token array")],
+var zVpTokenPex = import_zod15.z.union(
+  [zVpTokenPexEntry, import_zod15.z.array(zVpTokenPexEntry).nonempty("Must have at least entry in vp_token array")],
   {
     message: "pex vp_token must be a string, object or array of strings and objects"
   }
 );
-var zVpTokenDcql = import_zod16.z.record(import_zod16.z.union([import_zod16.z.string(), import_zod16.z.record(import_zod16.z.any())]), {
+var zVpTokenDcql = import_zod15.z.record(import_zod15.z.union([import_zod15.z.string(), import_zod15.z.record(import_zod15.z.any())]), {
   message: "dcql vp_token must be an object with keys referencing the dcql credential query id, and values the encoded (string or object) presentation"
 });
 var zVpToken = zVpTokenDcql.or(zVpTokenPex);
@@ -1567,23 +1564,23 @@ var import_utils21 = require("@openid4vc/utils");
 
 // src/authorization-response/z-authorization-response.ts
 var import_utils20 = require("@openid4vc/utils");
-var import_zod18 = require("zod");
+var import_zod17 = require("zod");
 
 // src/models/z-pex.ts
-var import_zod17 = require("zod");
-var zPexPresentationDefinition = import_zod17.z.record(import_zod17.z.any());
-var zPexPresentationSubmission = import_zod17.z.record(import_zod17.z.any());
+var import_zod16 = require("zod");
+var zPexPresentationDefinition = import_zod16.z.record(import_zod16.z.any());
+var zPexPresentationSubmission = import_zod16.z.record(import_zod16.z.any());
 
 // src/authorization-response/z-authorization-response.ts
-var zOpenid4vpAuthorizationResponse = import_zod18.z.object({
-  state: import_zod18.z.string().optional(),
-  id_token: import_zod18.z.string().optional(),
+var zOpenid4vpAuthorizationResponse = import_zod17.z.object({
+  state: import_zod17.z.string().optional(),
+  id_token: import_zod17.z.string().optional(),
   vp_token: zVpToken,
   presentation_submission: zPexPresentationSubmission.or(import_utils20.zStringToJson).optional(),
-  refresh_token: import_zod18.z.string().optional(),
-  token_type: import_zod18.z.string().optional(),
-  access_token: import_zod18.z.string().optional(),
-  expires_in: import_zod18.z.number().optional()
+  refresh_token: import_zod17.z.string().optional(),
+  token_type: import_zod17.z.string().optional(),
+  access_token: import_zod17.z.string().optional(),
+  expires_in: import_zod17.z.number().optional()
 }).passthrough();
 
 // src/authorization-response/parse-authorization-response-payload.ts
@@ -1598,11 +1595,11 @@ function parseOpenid4VpAuthorizationResponsePayload(payload) {
 // src/authorization-response/parse-jarm-authorization-response.ts
 var import_oauth226 = require("@openid4vc/oauth2");
 var import_utils22 = require("@openid4vc/utils");
-var import_zod19 = __toESM(require("zod"));
+var import_zod18 = __toESM(require("zod"));
 async function parseJarmAuthorizationResponse(options) {
   const { jarmResponseJwt, callbacks, authorizationRequestPayload, expectedClientId } = options;
   const jarmAuthorizationResponseJwt = (0, import_utils22.parseWithErrorHandling)(
-    import_zod19.default.union([import_oauth226.zCompactJwt, import_oauth226.zCompactJwe]),
+    import_zod18.default.union([import_oauth226.zCompactJwt, import_oauth226.zCompactJwe]),
     jarmResponseJwt,
     "Invalid jarm authorization response jwt."
   );
@@ -1796,22 +1793,22 @@ var Openid4vpVerifier = class {
 };
 
 // src/models/z-credential-formats.ts
-var import_zod20 = require("zod");
-var zCredentialFormat = import_zod20.z.enum(["jwt_vc_json", "ldp_vc", "ac_vc", "mso_mdoc", "dc+sd-jwt", "vc+sd-jwt"]);
+var import_zod19 = require("zod");
+var zCredentialFormat = import_zod19.z.enum(["jwt_vc_json", "ldp_vc", "ac_vc", "mso_mdoc", "dc+sd-jwt", "vc+sd-jwt"]);
 
 // src/models/z-proof-formats.ts
-var import_zod21 = require("zod");
-var zProofFormat = import_zod21.z.enum(["jwt_vp_json", "ldc_vp", "ac_vp", "dc+sd-jwt", "vc+sd-jwt", "mso_mdoc"]);
+var import_zod20 = require("zod");
+var zProofFormat = import_zod20.z.enum(["jwt_vp_json", "ldc_vp", "ac_vp", "dc+sd-jwt", "vc+sd-jwt", "mso_mdoc"]);
 
 // src/models/z-wallet-metadata.ts
-var import_zod22 = require("zod");
-var zWalletMetadata = import_zod22.z.object({
-  presentation_definition_uri_supported: import_zod22.z.optional(import_zod22.z.boolean()),
+var import_zod21 = require("zod");
+var zWalletMetadata = import_zod21.z.object({
+  presentation_definition_uri_supported: import_zod21.z.optional(import_zod21.z.boolean()),
   vp_formats_supported: zVpFormatsSupported,
-  client_id_schemes_supported: import_zod22.z.optional(import_zod22.z.array(zClientIdScheme)),
-  request_object_signing_alg_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string())),
-  authorization_encryption_alg_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string())),
-  authorization_encryption_enc_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string()))
+  client_id_schemes_supported: import_zod21.z.optional(import_zod21.z.array(zClientIdScheme)),
+  request_object_signing_alg_values_supported: import_zod21.z.optional(import_zod21.z.array(import_zod21.z.string())),
+  authorization_encryption_alg_values_supported: import_zod21.z.optional(import_zod21.z.array(import_zod21.z.string())),
+  authorization_encryption_enc_values_supported: import_zod21.z.optional(import_zod21.z.array(import_zod21.z.string()))
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {