@openid4vc/openid4vp 0.3.0-alpha-20250321130256 → 0.3.0-alpha-20250321132043

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import * as zod from 'zod';
 import zod__default, { z } from 'zod';
 import * as _openid4vc_oauth2 from '@openid4vc/oauth2';
-import { Jwk, JwtSignerWithJwk, CallbackContext, JwtSigner, HashAlgorithm } from '@openid4vc/oauth2';
+import { Jwk, JwtSignerWithJwk, CallbackContext, JwtPayload, JwtSigner, JweEncryptor, HashAlgorithm } from '@openid4vc/oauth2';
 
 declare const zOpenid4vpAuthorizationRequest: z.ZodObject<{
     response_type: z.ZodLiteral<"vp_token">;
@@ -9263,6 +9263,25 @@ declare const zJarmClientMetadata: z.ZodObject<{
 }>;
 type JarmClientMetadata = z.infer<typeof zJarmClientMetadata>;
 
+interface CreateJarAuthorizationRequestOptions {
+    authorizationRequestPayload: JwtPayload & {
+        client_id?: string;
+    };
+    requestUri?: string;
+    jwtSigner: JwtSigner;
+    jweEncryptor?: JweEncryptor;
+    callbacks: Pick<CallbackContext, 'signJwt' | 'encryptJwe'>;
+    /**
+     * Number of seconds after which the signed authorization request will expire
+     */
+    expiresInSeconds: number;
+    /**
+     * Date that should be used as now. If not provided current date will be used.
+     */
+    now?: Date;
+    additionalJwtPayload?: Record<string, unknown>;
+}
+
 interface WalletVerificationOptions {
     expectedNonce?: string;
     metadata?: WalletMetadata;
@@ -9279,13 +9298,13 @@ declare const validateOpenid4vpAuthorizationRequestPayload: (options: ValidateOp
 interface CreateOpenid4vpAuthorizationRequestOptions {
     scheme?: string;
     authorizationRequestPayload: Openid4vpAuthorizationRequest | Openid4vpAuthorizationRequestDcApi;
-    jar?: {
-        requestUri?: string;
-        jwtSigner: JwtSigner;
-        additionalJwtPayload?: Record<string, unknown>;
-    };
+    jar?: Pick<CreateJarAuthorizationRequestOptions, 'additionalJwtPayload' | 'requestUri' | 'jwtSigner' | 'expiresInSeconds'>;
     wallet?: WalletVerificationOptions;
     callbacks: Pick<CallbackContext, 'signJwt' | 'encryptJwe'>;
+    /**
+     * Date that should be used as now. If not provided current date will be used.
+     */
+    now?: Date;
 }
 /**
  * Creates an OpenID4VP authorization request, optionally with a JWT Secured Authorization Request (JAR)
@@ -11505,9 +11524,10 @@ declare function createOpenid4vpAuthorizationRequest(options: CreateOpenid4vpAut
             x5u: zod.ZodOptional<zod.ZodString>;
         }, zod.ZodTypeAny, "passthrough"> | undefined;
         authorizationRequestJwt: string;
-        requestUri?: string;
-        jwtSigner: JwtSigner;
-        additionalJwtPayload?: Record<string, unknown>;
+        expiresInSeconds: number;
+        requestUri?: string | undefined;
+        jwtSigner: _openid4vc_oauth2.JwtSigner;
+        additionalJwtPayload?: Record<string, unknown> | undefined;
     };
 } | {
     authorizationRequestPayload: zod.objectOutputType<{
@@ -18457,9 +18477,10 @@ declare class Openid4vpVerifier {
                 x5u: zod.ZodOptional<zod.ZodString>;
             }, zod.ZodTypeAny, "passthrough"> | undefined;
             authorizationRequestJwt: string;
-            requestUri?: string;
+            expiresInSeconds: number;
+            requestUri?: string | undefined;
             jwtSigner: _openid4vc_oauth2.JwtSigner;
-            additionalJwtPayload?: Record<string, unknown>;
+            additionalJwtPayload?: Record<string, unknown> | undefined;
         };
     } | {
         authorizationRequestPayload: zod.objectOutputType<{

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as zod from 'zod';
 import zod__default, { z } from 'zod';
 import * as _openid4vc_oauth2 from '@openid4vc/oauth2';
-import { Jwk, JwtSignerWithJwk, CallbackContext, JwtSigner, HashAlgorithm } from '@openid4vc/oauth2';
+import { Jwk, JwtSignerWithJwk, CallbackContext, JwtPayload, JwtSigner, JweEncryptor, HashAlgorithm } from '@openid4vc/oauth2';
 
 declare const zOpenid4vpAuthorizationRequest: z.ZodObject<{
     response_type: z.ZodLiteral<"vp_token">;
@@ -9263,6 +9263,25 @@ declare const zJarmClientMetadata: z.ZodObject<{
 }>;
 type JarmClientMetadata = z.infer<typeof zJarmClientMetadata>;
 
+interface CreateJarAuthorizationRequestOptions {
+    authorizationRequestPayload: JwtPayload & {
+        client_id?: string;
+    };
+    requestUri?: string;
+    jwtSigner: JwtSigner;
+    jweEncryptor?: JweEncryptor;
+    callbacks: Pick<CallbackContext, 'signJwt' | 'encryptJwe'>;
+    /**
+     * Number of seconds after which the signed authorization request will expire
+     */
+    expiresInSeconds: number;
+    /**
+     * Date that should be used as now. If not provided current date will be used.
+     */
+    now?: Date;
+    additionalJwtPayload?: Record<string, unknown>;
+}
+
 interface WalletVerificationOptions {
     expectedNonce?: string;
     metadata?: WalletMetadata;
@@ -9279,13 +9298,13 @@ declare const validateOpenid4vpAuthorizationRequestPayload: (options: ValidateOp
 interface CreateOpenid4vpAuthorizationRequestOptions {
     scheme?: string;
     authorizationRequestPayload: Openid4vpAuthorizationRequest | Openid4vpAuthorizationRequestDcApi;
-    jar?: {
-        requestUri?: string;
-        jwtSigner: JwtSigner;
-        additionalJwtPayload?: Record<string, unknown>;
-    };
+    jar?: Pick<CreateJarAuthorizationRequestOptions, 'additionalJwtPayload' | 'requestUri' | 'jwtSigner' | 'expiresInSeconds'>;
     wallet?: WalletVerificationOptions;
     callbacks: Pick<CallbackContext, 'signJwt' | 'encryptJwe'>;
+    /**
+     * Date that should be used as now. If not provided current date will be used.
+     */
+    now?: Date;
 }
 /**
  * Creates an OpenID4VP authorization request, optionally with a JWT Secured Authorization Request (JAR)
@@ -11505,9 +11524,10 @@ declare function createOpenid4vpAuthorizationRequest(options: CreateOpenid4vpAut
             x5u: zod.ZodOptional<zod.ZodString>;
         }, zod.ZodTypeAny, "passthrough"> | undefined;
         authorizationRequestJwt: string;
-        requestUri?: string;
-        jwtSigner: JwtSigner;
-        additionalJwtPayload?: Record<string, unknown>;
+        expiresInSeconds: number;
+        requestUri?: string | undefined;
+        jwtSigner: _openid4vc_oauth2.JwtSigner;
+        additionalJwtPayload?: Record<string, unknown> | undefined;
     };
 } | {
     authorizationRequestPayload: zod.objectOutputType<{
@@ -18457,9 +18477,10 @@ declare class Openid4vpVerifier {
                 x5u: zod.ZodOptional<zod.ZodString>;
             }, zod.ZodTypeAny, "passthrough"> | undefined;
             authorizationRequestJwt: string;
-            requestUri?: string;
+            expiresInSeconds: number;
+            requestUri?: string | undefined;
             jwtSigner: _openid4vc_oauth2.JwtSigner;
-            additionalJwtPayload?: Record<string, unknown>;
+            additionalJwtPayload?: Record<string, unknown> | undefined;
         };
     } | {
         authorizationRequestPayload: zod.objectOutputType<{

package/dist/index.js

@@ -609,17 +609,24 @@ async function verifyJarmAuthorizationResponse(options) {
 
 // src/authorization-request/create-authorization-request.ts
 var import_oauth210 = require("@openid4vc/oauth2");
-var import_utils7 = require("@openid4vc/utils");
+var import_utils8 = require("@openid4vc/utils");
 
 // src/jar/create-jar-authorization-request.ts
 var import_oauth27 = require("@openid4vc/oauth2");
+var import_utils6 = require("@openid4vc/utils");
 async function createJarAuthorizationRequest(options) {
   const { jwtSigner, jweEncryptor, authorizationRequestPayload, requestUri, callbacks } = options;
   let authorizationRequestJwt;
   let encryptionJwk;
+  const now = options.now ?? /* @__PURE__ */ new Date();
   const { jwt, signerJwk } = await callbacks.signJwt(jwtSigner, {
     header: { ...(0, import_oauth27.jwtHeaderFromJwtSigner)(jwtSigner), typ: "oauth-authz-req+jwt" },
-    payload: { ...options.additionalJwtPayload, ...authorizationRequestPayload }
+    payload: {
+      iat: (0, import_utils6.dateToSeconds)(now),
+      exp: (0, import_utils6.dateToSeconds)((0, import_utils6.addSecondsToDate)(now, options.expiresInSeconds)),
+      ...options.additionalJwtPayload,
+      ...authorizationRequestPayload
+    }
   });
   authorizationRequestJwt = jwt;
   if (jweEncryptor) {
@@ -634,7 +641,7 @@ async function createJarAuthorizationRequest(options) {
 
 // src/authorization-request/validate-authorization-request.ts
 var import_oauth28 = require("@openid4vc/oauth2");
-var import_utils6 = require("@openid4vc/utils");
+var import_utils7 = require("@openid4vc/utils");
 var validateOpenid4vpAuthorizationRequestPayload = (options) => {
   const { params, walletVerificationOptions } = options;
   if (!params.redirect_uri && !params.response_uri) {
@@ -669,7 +676,7 @@ var validateOpenid4vpAuthorizationRequestPayload = (options) => {
       error_description: `The 'request_uri_method' parameter MUST be 'GET' or 'POST'. Current: ${params.request_uri_method}`
     });
   }
-  if (params.trust_chain && !import_utils6.zHttpsUrl.safeParse(params.client_id).success) {
+  if (params.trust_chain && !import_utils7.zHttpsUrl.safeParse(params.client_id).success) {
     throw new import_oauth28.Oauth2ServerErrorResponseError({
       error: import_oauth28.Oauth2ErrorCodes.InvalidRequest,
       error_description: 'The "trust_chain" parameter MUST NOT be present in the authorization request if the "client_id" is not an OpenId Federation Entity Identifier starting with http:// or https://.'
@@ -733,7 +740,7 @@ async function createOpenid4vpAuthorizationRequest(options) {
   let additionalJwtPayload;
   let authorizationRequestPayload;
   if (isOpenid4vpAuthorizationRequestDcApi(options.authorizationRequestPayload)) {
-    authorizationRequestPayload = (0, import_utils7.parseWithErrorHandling)(
+    authorizationRequestPayload = (0, import_utils8.parseWithErrorHandling)(
       zOpenid4vpAuthorizationRequestDcApi,
       options.authorizationRequestPayload,
       "Invalid authorization request. Could not parse openid4vp dc_api authorization request."
@@ -749,7 +756,7 @@ async function createOpenid4vpAuthorizationRequest(options) {
       disableOriginValidation: true
     });
   } else {
-    authorizationRequestPayload = (0, import_utils7.parseWithErrorHandling)(
+    authorizationRequestPayload = (0, import_utils8.parseWithErrorHandling)(
       zOpenid4vpAuthorizationRequest,
       options.authorizationRequestPayload,
       "Invalid authorization request. Could not parse openid4vp authorization request."
@@ -769,10 +776,10 @@ async function createOpenid4vpAuthorizationRequest(options) {
       additionalJwtPayload,
       callbacks
     });
-    const url2 = new import_utils7.URL(scheme);
-    url2.search = `?${new import_utils7.URLSearchParams([
+    const url2 = new import_utils8.URL(scheme);
+    url2.search = `?${new import_utils8.URLSearchParams([
       ...url2.searchParams.entries(),
-      ...(0, import_utils7.objectToQueryParams)(jarResult.jarAuthorizationRequest).entries()
+      ...(0, import_utils8.objectToQueryParams)(jarResult.jarAuthorizationRequest).entries()
     ]).toString()}`;
     return {
       authorizationRequestPayload,
@@ -781,10 +788,10 @@ async function createOpenid4vpAuthorizationRequest(options) {
       jar: { ...jar, ...jarResult }
     };
   }
-  const url = new import_utils7.URL(scheme);
-  url.search = `?${new import_utils7.URLSearchParams([
+  const url = new import_utils8.URL(scheme);
+  url.search = `?${new import_utils8.URLSearchParams([
     ...url.searchParams.entries(),
-    ...(0, import_utils7.objectToQueryParams)(authorizationRequestPayload).entries()
+    ...(0, import_utils8.objectToQueryParams)(authorizationRequestPayload).entries()
   ]).toString()}`;
   return {
     authorizationRequestPayload,
@@ -796,16 +803,16 @@ async function createOpenid4vpAuthorizationRequest(options) {
 
 // src/authorization-request/parse-authorization-request-params.ts
 var import_oauth212 = require("@openid4vc/oauth2");
-var import_utils9 = require("@openid4vc/utils");
+var import_utils10 = require("@openid4vc/utils");
 var import_zod10 = __toESM(require("zod"));
 
 // src/jar/z-jar-authorization-request.ts
 var import_oauth211 = require("@openid4vc/oauth2");
-var import_utils8 = require("@openid4vc/utils");
+var import_utils9 = require("@openid4vc/utils");
 var import_zod9 = require("zod");
 var zJarAuthorizationRequest = import_zod9.z.object({
   request: import_zod9.z.optional(import_zod9.z.string()),
-  request_uri: import_zod9.z.optional(import_utils8.zHttpsUrl),
+  request_uri: import_zod9.z.optional(import_utils9.zHttpsUrl),
   request_uri_method: import_zod9.z.optional(import_zod9.z.string()),
   client_id: import_zod9.z.optional(import_zod9.z.string())
 }).passthrough();
@@ -836,7 +843,7 @@ function parseOpenid4vpAuthorizationRequest(options) {
   let params;
   if (typeof authorizationRequest === "string") {
     if (authorizationRequest.includes("://")) {
-      params = (0, import_utils9.parseWithErrorHandling)(
+      params = (0, import_utils10.parseWithErrorHandling)(
         zOpenid4vpAuthorizationRequestFromUriParams,
         authorizationRequest,
         "Unable to parse openid4vp authorization request uri to a valid object"
@@ -850,7 +857,7 @@ function parseOpenid4vpAuthorizationRequest(options) {
   } else {
     params = authorizationRequest;
   }
-  const parsedRequest = (0, import_utils9.parseWithErrorHandling)(
+  const parsedRequest = (0, import_utils10.parseWithErrorHandling)(
     import_zod10.default.union([zOpenid4vpAuthorizationRequest, zJarAuthorizationRequest, zOpenid4vpAuthorizationRequestDcApi]),
     params
   );
@@ -877,19 +884,19 @@ function parseOpenid4vpAuthorizationRequest(options) {
 
 // src/authorization-request/resolve-authorization-request.ts
 var import_oauth219 = require("@openid4vc/oauth2");
-var import_utils13 = require("@openid4vc/utils");
+var import_utils14 = require("@openid4vc/utils");
 var import_zod14 = __toESM(require("zod"));
 
 // src/fetch-client-metadata.ts
 var import_oauth213 = require("@openid4vc/oauth2");
-var import_utils10 = require("@openid4vc/utils");
+var import_utils11 = require("@openid4vc/utils");
 async function fetchClientMetadata(options) {
   const { fetch, clientMetadataUri } = options;
-  const fetcher = (0, import_utils10.createZodFetcher)(fetch);
-  const { result, response } = await fetcher(zClientMetadata, import_utils10.ContentType.Json, clientMetadataUri, {
+  const fetcher = (0, import_utils11.createZodFetcher)(fetch);
+  const { result, response } = await fetcher(zClientMetadata, import_utils11.ContentType.Json, clientMetadataUri, {
     method: "GET",
     headers: {
-      Accept: import_utils10.ContentType.Json
+      Accept: import_utils11.ContentType.Json
     }
   });
   if (!response.ok) {
@@ -974,23 +981,23 @@ function parseAuthorizationRequestVersion(request) {
 
 // src/jar/jar-request-object/fetch-jar-request-object.ts
 var import_oauth215 = require("@openid4vc/oauth2");
-var import_utils11 = require("@openid4vc/utils");
+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_utils11.createZodFetcher)(fetch);
+  const fetcher = (0, import_utils12.createZodFetcher)(fetch);
   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_utils11.ContentType.OAuthAuthorizationRequestJwt, requestUri, {
+  const { result, response } = await fetcher(import_zod11.z.string(), import_utils12.ContentType.OAuthAuthorizationRequestJwt, requestUri, {
     method,
     headers: {
-      Accept: `${import_utils11.ContentType.OAuthAuthorizationRequestJwt}, ${import_utils11.ContentType.Jwt};q=0.9`,
-      "Content-Type": import_utils11.ContentType.XWwwFormUrlencoded
+      Accept: `${import_utils12.ContentType.OAuthAuthorizationRequestJwt}, ${import_utils12.ContentType.Jwt};q=0.9`,
+      "Content-Type": import_utils12.ContentType.XWwwFormUrlencoded
     },
-    body: method === "POST" ? (0, import_utils11.objectToQueryParams)(wallet.metadata ?? {}) : void 0
+    body: method === "POST" ? (0, import_utils12.objectToQueryParams)(wallet.metadata ?? {}) : void 0
   });
   if (!response.ok) {
     throw new import_oauth215.Oauth2ServerErrorResponseError({
@@ -1107,7 +1114,7 @@ async function verifyJarRequestObject(options) {
 
 // src/transaction-data/parse-transaction-data.ts
 var import_oauth218 = require("@openid4vc/oauth2");
-var import_utils12 = require("@openid4vc/utils");
+var import_utils13 = require("@openid4vc/utils");
 
 // src/transaction-data/z-transaction-data.ts
 var import_zod13 = require("zod");
@@ -1121,7 +1128,7 @@ var zTransactionData = import_zod13.z.array(zTransactionEntry);
 // src/transaction-data/parse-transaction-data.ts
 function parseTransactionData(options) {
   const { transactionData } = options;
-  const decoded = transactionData.map((tdEntry) => (0, import_utils12.parseIfJson)((0, import_utils12.encodeToUtf8String)((0, import_utils12.decodeBase64)(tdEntry))));
+  const decoded = transactionData.map((tdEntry) => (0, import_utils13.parseIfJson)((0, import_utils13.encodeToUtf8String)((0, import_utils13.decodeBase64)(tdEntry))));
   const parsedResult = zTransactionData.safeParse(decoded);
   if (!parsedResult.success) {
     throw new import_oauth218.Oauth2ServerErrorResponseError({
@@ -1140,7 +1147,7 @@ function parseTransactionData(options) {
 async function resolveOpenid4vpAuthorizationRequest(options) {
   const { wallet, callbacks, origin, disableOriginValidation } = options;
   let authorizationRequestPayload;
-  const parsed = (0, import_utils13.parseWithErrorHandling)(
+  const parsed = (0, import_utils14.parseWithErrorHandling)(
     import_zod14.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest, zJarAuthorizationRequest]),
     options.authorizationRequestPayload,
     "Invalid authorization request. Could not parse openid4vp authorization request as openid4vp or jar auth request."
@@ -1148,7 +1155,7 @@ async function resolveOpenid4vpAuthorizationRequest(options) {
   let jar;
   if (isJarAuthorizationRequest(parsed)) {
     jar = await verifyJarRequest({ jarRequestParams: parsed, callbacks, wallet });
-    const parsedJarAuthorizationRequestPayload = (0, import_utils13.parseWithErrorHandling)(
+    const parsedJarAuthorizationRequestPayload = (0, import_utils14.parseWithErrorHandling)(
       import_zod14.default.union([zOpenid4vpAuthorizationRequestDcApi, zOpenid4vpAuthorizationRequest]),
       jar.authorizationRequestParams,
       "Invalid authorization request. Could not parse jar request payload as openid4vp auth request."
@@ -1229,10 +1236,10 @@ function validateOpenId4vpAuthorizationRequestPayload(options) {
 
 // src/authorization-response/create-authorization-response.ts
 var import_oauth222 = require("@openid4vc/oauth2");
-var import_utils14 = require("@openid4vc/utils");
+var import_utils15 = require("@openid4vc/utils");
 
 // ../utils/src/date.ts
-function addSecondsToDate(date, seconds) {
+function addSecondsToDate2(date, seconds) {
   return new Date(date.getTime() + seconds * 1e3);
 }
 
@@ -1373,7 +1380,7 @@ async function createOpenid4vpAuthorizationResponse(options) {
     additionalJwtPayload = {
       iss: jarm.authorizationServer,
       aud: jarm.audience,
-      exp: jarm.expiresInSeconds ?? (0, import_utils14.dateToSeconds)(addSecondsToDate(/* @__PURE__ */ new Date(), 60 * 10))
+      exp: jarm.expiresInSeconds ?? (0, import_utils15.dateToSeconds)(addSecondsToDate2(/* @__PURE__ */ new Date(), 60 * 10))
       // default: 10 minutes
     };
   }
@@ -1405,25 +1412,25 @@ async function createOpenid4vpAuthorizationResponse(options) {
 
 // src/authorization-response/submit-authorization-response.ts
 var import_oauth224 = require("@openid4vc/oauth2");
-var import_utils16 = require("@openid4vc/utils");
 var import_utils17 = require("@openid4vc/utils");
+var import_utils18 = require("@openid4vc/utils");
 
 // src/jarm/jarm-authorizatino-response-send.ts
 var import_oauth223 = require("@openid4vc/oauth2");
-var import_utils15 = require("@openid4vc/utils");
+var import_utils16 = require("@openid4vc/utils");
 var jarmAuthorizationResponseSend = (options) => {
   const { authorizationRequestPayload, jarmAuthorizationResponseJwt, callbacks } = options;
   const responseEndpoint = authorizationRequestPayload.response_uri ?? authorizationRequestPayload.redirect_uri;
   if (!responseEndpoint) {
     throw new import_oauth223.Oauth2Error(`Either 'response_uri' or 'redirect_uri' MUST  be present in the authorization request`);
   }
-  const responseEndpointUrl = new import_utils15.URL(responseEndpoint);
+  const responseEndpointUrl = new import_utils16.URL(responseEndpoint);
   return handleDirectPostJwt(responseEndpointUrl, jarmAuthorizationResponseJwt, callbacks);
 };
 async function handleDirectPostJwt(responseEndpoint, responseJwt, callbacks) {
-  const response = await (callbacks.fetch ?? import_utils15.defaultFetcher)(responseEndpoint, {
+  const response = await (callbacks.fetch ?? import_utils16.defaultFetcher)(responseEndpoint, {
     method: "POST",
-    headers: { "Content-Type": import_utils15.ContentType.XWwwFormUrlencoded },
+    headers: { "Content-Type": import_utils16.ContentType.XWwwFormUrlencoded },
     body: `response=${responseJwt}`
   });
   return {
@@ -1448,13 +1455,13 @@ async function submitOpenid4vpAuthorizationResponse(options) {
       "Failed to submit OpenId4Vp Authorization Response. No redirect_uri or response_uri provided."
     );
   }
-  const fetch = callbacks.fetch ?? import_utils16.defaultFetcher;
-  const encodedResponse = (0, import_utils17.objectToQueryParams)(authorizationResponsePayload);
+  const fetch = callbacks.fetch ?? import_utils17.defaultFetcher;
+  const encodedResponse = (0, import_utils18.objectToQueryParams)(authorizationResponsePayload);
   const submissionResponse = await fetch(url, {
     method: "POST",
     body: encodedResponse,
     headers: {
-      "Content-Type": import_utils16.ContentType.XWwwFormUrlencoded
+      "Content-Type": import_utils17.ContentType.XWwwFormUrlencoded
     }
   });
   return {
@@ -1467,7 +1474,7 @@ async function submitOpenid4vpAuthorizationResponse(options) {
 var import_oauth225 = require("@openid4vc/oauth2");
 
 // src/vp-token/parse-vp-token.ts
-var import_utils18 = require("@openid4vc/utils");
+var import_utils19 = require("@openid4vc/utils");
 
 // src/vp-token/z-vp-token.ts
 var import_zod16 = require("zod");
@@ -1487,17 +1494,17 @@ var zVpToken = zVpTokenDcql.or(zVpTokenPex);
 
 // src/vp-token/parse-vp-token.ts
 function parsePexVpToken(vpToken) {
-  const parsedVpToken = (0, import_utils18.parseWithErrorHandling)(
+  const parsedVpToken = (0, import_utils19.parseWithErrorHandling)(
     zVpTokenPex,
-    (0, import_utils18.parseIfJson)(vpToken),
+    (0, import_utils19.parseIfJson)(vpToken),
     "Could not parse presentation exchange vp_token. Expected a string or an array of strings"
   );
   return Array.isArray(parsedVpToken) ? parsedVpToken : [parsedVpToken];
 }
 function parseDcqlVpToken(vpToken) {
-  return (0, import_utils18.parseWithErrorHandling)(
+  return (0, import_utils19.parseWithErrorHandling)(
     zVpTokenDcql,
-    (0, import_utils18.parseIfJson)(vpToken),
+    (0, import_utils19.parseIfJson)(vpToken),
     "Could not parse dcql vp_token. Expected an object where the values are encoded presentations"
   );
 }
@@ -1550,10 +1557,10 @@ function validateOpenid4vpAuthorizationResponsePayload(options) {
 var import_oauth227 = require("@openid4vc/oauth2");
 
 // src/authorization-response/parse-authorization-response-payload.ts
-var import_utils20 = require("@openid4vc/utils");
+var import_utils21 = require("@openid4vc/utils");
 
 // src/authorization-response/z-authorization-response.ts
-var import_utils19 = require("@openid4vc/utils");
+var import_utils20 = require("@openid4vc/utils");
 var import_zod18 = require("zod");
 
 // src/models/z-pex.ts
@@ -1566,7 +1573,7 @@ var zOpenid4vpAuthorizationResponse = import_zod18.z.object({
   state: import_zod18.z.string().optional(),
   id_token: import_zod18.z.string().optional(),
   vp_token: zVpToken,
-  presentation_submission: zPexPresentationSubmission.or(import_utils19.zStringToJson).optional(),
+  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(),
@@ -1575,7 +1582,7 @@ var zOpenid4vpAuthorizationResponse = import_zod18.z.object({
 
 // src/authorization-response/parse-authorization-response-payload.ts
 function parseOpenid4VpAuthorizationResponsePayload(payload) {
-  return (0, import_utils20.parseWithErrorHandling)(
+  return (0, import_utils21.parseWithErrorHandling)(
     zOpenid4vpAuthorizationResponse,
     payload,
     "Failed to parse openid4vp authorization response."
@@ -1584,11 +1591,11 @@ function parseOpenid4VpAuthorizationResponsePayload(payload) {
 
 // src/authorization-response/parse-jarm-authorization-response.ts
 var import_oauth226 = require("@openid4vc/oauth2");
-var import_utils21 = require("@openid4vc/utils");
+var import_utils22 = require("@openid4vc/utils");
 var import_zod19 = __toESM(require("zod"));
 async function parseJarmAuthorizationResponse(options) {
   const { jarmResponseJwt, callbacks, authorizationRequestPayload, expectedClientId } = options;
-  const jarmAuthorizationResponseJwt = (0, import_utils21.parseWithErrorHandling)(
+  const jarmAuthorizationResponseJwt = (0, import_utils22.parseWithErrorHandling)(
     import_zod19.default.union([import_oauth226.zCompactJwt, import_oauth226.zCompactJwe]),
     jarmResponseJwt,
     "Invalid jarm authorization response jwt."
@@ -1685,7 +1692,7 @@ var Openid4vpClient = class {
 
 // src/transaction-data/verify-transaction-data.ts
 var import_oauth228 = require("@openid4vc/oauth2");
-var import_utils22 = require("@openid4vc/utils");
+var import_utils23 = require("@openid4vc/utils");
 async function verifyTransactionData(options) {
   const parsedTransactionData = parseTransactionData({
     transactionData: options.transactionData
@@ -1712,7 +1719,7 @@ async function verifyTransactionDataEntry({
   );
   const hashes = {};
   for (const alg of supportedAlgs) {
-    hashes[alg] = (0, import_utils22.encodeToBase64Url)(await callbacks.hash((0, import_utils22.decodeUtf8String)(entry.encoded), alg));
+    hashes[alg] = (0, import_utils23.encodeToBase64Url)(await callbacks.hash((0, import_utils23.decodeUtf8String)(entry.encoded), alg));
   }
   for (const credentialId of entry.transactionData.credential_ids) {
     const transactionDataHashesCredential = credentials[credentialId];