@pagopa/io-react-native-wallet 3.6.3 → 3.7.0

package/src/credential/issuance/v1.0.0/03-complete-user-authorization.ts

@@ -1,35 +1,37 @@
+import {
+  type CryptoContext,
+  decode,
+  SignJWT,
+} from "@pagopa/io-react-native-jwt";
+import parseUrl from "parse-url";
+
+import type { RemotePresentation } from "../../presentation";
+import type { IssuanceApi } from "../api";
+
 import {
   AuthorizationChallengeResultShape,
   AuthorizationErrorShape,
-  AuthorizationResultShape,
   type AuthorizationResult,
+  AuthorizationResultShape,
 } from "../../../utils/auth";
-import { hasStatusOrThrow } from "../../../utils/misc";
-import parseUrl from "parse-url";
+import { getJwtFromFormPost } from "../../../utils/decoder";
 import {
   IssuerResponseError,
   UnimplementedFeatureError,
   ValidationFailed,
 } from "../../../utils/errors";
-import {
-  decode,
-  SignJWT,
-  type CryptoContext,
-} from "@pagopa/io-react-native-jwt";
-import { ResponseUriResultShape } from "./types";
-import { getJwtFromFormPost } from "../../../utils/decoder";
-import { AuthorizationError, AuthorizationIdpError } from "../common/errors";
-import { LogLevel, Logger } from "../../../utils/logging";
-import { RawRequestObject } from "../../presentation/v1.0.0/types";
+import { Logger, LogLevel } from "../../../utils/logging";
+import { hasStatusOrThrow } from "../../../utils/misc";
 import { RemotePresentation as RemotePresentationFlow } from "../../presentation/v1.0.0";
-import type { IssuanceApi } from "../api";
-import type { RemotePresentation } from "../../presentation";
+import { RawRequestObject } from "../../presentation/v1.0.0/types";
+import { AuthorizationError, AuthorizationIdpError } from "../common/errors";
+import { ResponseUriResultShape } from "./types";
 
 export const continueUserAuthorizationWithMRTDPoPChallenge: IssuanceApi["continueUserAuthorizationWithMRTDPoPChallenge"] =
   async (authRedirectUrl) => {
     Logger.log(
       LogLevel.DEBUG,
-      `The requested credential is a PersonIdentificationData and requires MRTD PoP, starting MRTD PoP validation from auth redirect`
+      `The requested credential is a PersonIdentificationData and requires MRTD PoP, starting MRTD PoP validation from auth redirect`,
     );
     const query = parseUrl(authRedirectUrl).query;
 
@@ -39,17 +41,17 @@ export const continueUserAuthorizationWithMRTDPoPChallenge: IssuanceApi["continu
       if (!authErr.success) {
         Logger.log(
           LogLevel.ERROR,
-          `Error while parsing the authorization response: ${authResParsed.error.message}`
+          `Error while parsing the authorization response: ${authResParsed.error.message}`,
         );
         throw new AuthorizationError(authResParsed.error.message); // an error occured while parsing the result and the error
       }
       Logger.log(
         LogLevel.ERROR,
-        `Error while authorizating with the idp: ${JSON.stringify(authErr)}`
+        `Error while authorizating with the idp: ${JSON.stringify(authErr)}`,
       );
       throw new AuthorizationIdpError(
         authErr.data.error,
-        authErr.data.error_description
+        authErr.data.error_description,
       );
     }
     return authResParsed.data;
@@ -77,7 +79,7 @@ export const completePidUserAuthorizationWithQueryMode: IssuanceApi["completePid
   async (authRedirectUrl) => {
     Logger.log(
       LogLevel.DEBUG,
-      `The requested credential is a PersonIdentificationData, completing the user authorization with query mode`
+      `The requested credential is a PersonIdentificationData, completing the user authorization with query mode`,
     );
     const query = parseUrl(authRedirectUrl).query;
 
@@ -88,7 +90,7 @@ export const completeEaaUserAuthorizationWithQueryMode: IssuanceApi["completeEaa
   () => {
     throw new UnimplementedFeatureError(
       "completeEaaUserAuthorizationWithQueryMode",
-      "1.0.0"
+      "1.0.0",
     );
   };
 
@@ -96,7 +98,7 @@ export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCrede
   async (issuerRequestUri, clientId, issuerConf, appFetch = fetch) => {
     Logger.log(
       LogLevel.DEBUG,
-      `The requeste credential is not a PersonIdentificationData, requesting the credential to be presented`
+      `The requeste credential is not a PersonIdentificationData, requesting the credential to be presented`,
     );
     const authzRequestEndpoint = issuerConf.authorization_endpoint;
     const params = new URLSearchParams({
@@ -106,12 +108,12 @@ export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCrede
 
     Logger.log(
       LogLevel.DEBUG,
-      `Requesting the request object to ${authzRequestEndpoint}?${params.toString()}`
+      `Requesting the request object to ${authzRequestEndpoint}?${params.toString()}`,
     );
 
     const requestObject = await appFetch(
       `${authzRequestEndpoint}?${params.toString()}`,
-      { method: "GET" }
+      { method: "GET" },
     )
       .then(hasStatusOrThrow(200, IssuerResponseError))
       .then((res) => res.text())
@@ -120,13 +122,13 @@ export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCrede
         RawRequestObject.safeParse({
           header: reqObj.protectedHeader,
           payload: reqObj.payload,
-        })
+        }),
       );
 
     if (!requestObject.success) {
       Logger.log(
         LogLevel.ERROR,
-        `Error while validating the response object: ${requestObject.error.message}`
+        `Error while validating the response object: ${requestObject.error.message}`,
       );
       throw new ValidationFailed({
         message: "Request Object validation failed",
@@ -141,34 +143,34 @@ export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["complete
     requestObject,
     _issuerConfig,
     evaluatedDcqlQuery,
-    { wiaCryptoContext, appFetch = fetch }
+    { appFetch = fetch, wiaCryptoContext },
   ) => {
     Logger.log(
       LogLevel.DEBUG,
-      `The requeste credential is not a PersonIdentificationData, completing the user authorization with form_post.jwt mode`
+      `The requeste credential is not a PersonIdentificationData, completing the user authorization with form_post.jwt mode`,
     );
 
     const authRequestObject = {
-      nonce: requestObject.nonce,
       clientId: requestObject.client_id,
+      nonce: requestObject.nonce,
       responseUri: requestObject.response_uri,
     };
 
     const remotePresentation =
       await RemotePresentationFlow.prepareRemotePresentations(
         evaluatedDcqlQuery,
-        authRequestObject
+        authRequestObject,
       );
 
     const authzResponsePayload = await createAuthzResponsePayload({
-      state: requestObject.state,
       remotePresentation,
+      state: requestObject.state,
       wiaCryptoContext,
     });
 
     Logger.log(
       LogLevel.DEBUG,
-      `Authz response payload: ${authzResponsePayload}`
+      `Authz response payload: ${authzResponsePayload}`,
     );
 
     // Note: according to the spec, the response should be encrypted with the public key of the RP however this is not implemented yet
@@ -185,11 +187,11 @@ export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["complete
     }).toString();
 
     const resUriRes = await appFetch(requestObject.response_uri, {
-      method: "POST",
+      body,
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
       },
-      body,
+      method: "POST",
     })
       .then(hasStatusOrThrow(200, IssuerResponseError))
       .then((reqUri) => reqUri.json());
@@ -198,7 +200,7 @@ export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["complete
     if (!responseUri.success) {
       Logger.log(
         LogLevel.ERROR,
-        `Error while validating the response uri: ${responseUri.error.message}`
+        `Error while validating the response uri: ${responseUri.error.message}`,
       );
       throw new ValidationFailed({
         message: "Response Uri validation failed",
@@ -221,7 +223,7 @@ export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["complete
  * @returns the authorization result which contains code, state and iss
  */
 export const parseAuthorizationResponse = (
-  authRes: unknown
+  authRes: unknown,
 ): AuthorizationResult => {
   const authResParsed = AuthorizationResultShape.safeParse(authRes);
   if (!authResParsed.success) {
@@ -229,17 +231,17 @@ export const parseAuthorizationResponse = (
     if (!authErr.success) {
       Logger.log(
         LogLevel.ERROR,
-        `Error while parsing the authorization response: ${authResParsed.error.message}`
+        `Error while parsing the authorization response: ${authResParsed.error.message}`,
       );
       throw new AuthorizationError(authResParsed.error.message); // an error occured while parsing the result and the error
     }
     Logger.log(
       LogLevel.ERROR,
-      `Error while authorizating with the idp: ${JSON.stringify(authErr)}`
+      `Error while authorizating with the idp: ${JSON.stringify(authErr)}`,
     );
     throw new AuthorizationIdpError(
       authErr.data.error,
-      authErr.data.error_description
+      authErr.data.error_description,
     );
   }
   return authResParsed.data;
@@ -254,20 +256,20 @@ export const parseAuthorizationResponse = (
  * @returns The Base64 encoded authorization response payload.
  */
 const createAuthzResponsePayload = async ({
-  state,
   remotePresentation,
+  state,
   wiaCryptoContext,
 }: {
-  state?: string;
   remotePresentation: RemotePresentation;
+  state?: string;
   wiaCryptoContext: CryptoContext;
 }): Promise<string> => {
   const { kid } = await wiaCryptoContext.getPublicKey();
 
   return new SignJWT(wiaCryptoContext)
     .setProtectedHeader({
-      typ: "jwt",
       kid,
+      typ: "jwt",
     })
     .setPayload({
       /**
@@ -281,7 +283,7 @@ const createAuthzResponsePayload = async ({
           ...vp_token,
           [credentialId]: vpToken,
         }),
-        {}
+        {},
       ),
     })
     .setIssuedAt()

package/src/credential/issuance/v1.0.0/04-authorize-access.ts

@@ -1,25 +1,27 @@
 import { v4 as uuidv4 } from "uuid";
-import { hasStatusOrThrow } from "../../../utils/misc";
+
+import type { IssuanceApi } from "../api";
+
 import { createDPopToken } from "../../../utils/dpop";
-import { createPopToken } from "../../../utils/pop";
-import { TokenResponse } from "./types";
 import { IssuerResponseError, ValidationFailed } from "../../../utils/errors";
-import { LogLevel, Logger } from "../../../utils/logging";
-import type { IssuanceApi } from "../api";
+import { Logger, LogLevel } from "../../../utils/logging";
+import { hasStatusOrThrow } from "../../../utils/misc";
+import { createPopToken } from "../../../utils/pop";
 import * as WalletInstanceAttestation from "../../../wallet-instance-attestation/v1.0.0/utils";
+import { TokenResponse } from "./types";
 
 export const authorizeAccess: IssuanceApi["authorizeAccess"] = async (
   issuerConf,
   code,
   redirectUri,
   codeVerifier,
-  context
+  context,
 ) => {
   const {
     appFetch = fetch,
+    dPopCryptoContext,
     walletInstanceAttestation,
     wiaCryptoContext,
-    dPopCryptoContext,
   } = context;
   const aud = issuerConf.credential_issuer;
   const iss = WalletInstanceAttestation.decode(walletInstanceAttestation)
@@ -33,26 +35,26 @@ export const authorizeAccess: IssuanceApi["authorizeAccess"] = async (
       htu: tokenUrl,
       jti: `${uuidv4()}`,
     },
-    dPopCryptoContext
+    dPopCryptoContext,
   );
 
   Logger.log(LogLevel.DEBUG, `Token request DPoP: ${tokenRequestSignedDPop}`);
 
   const signedWiaPoP = await createPopToken(
     {
-      jti: `${uuidv4()}`,
       aud,
       iss,
+      jti: `${uuidv4()}`,
     },
-    wiaCryptoContext
+    wiaCryptoContext,
   );
 
   Logger.log(LogLevel.DEBUG, `WIA DPoP token: ${signedWiaPoP}`);
 
   const requestBody = {
-    grant_type: "authorization_code",
     code,
     code_verifier: codeVerifier,
+    grant_type: "authorization_code",
     redirect_uri: redirectUri,
   };
 
@@ -60,18 +62,18 @@ export const authorizeAccess: IssuanceApi["authorizeAccess"] = async (
 
   Logger.log(
     LogLevel.DEBUG,
-    `Auth form request body: ${authorizationRequestFormBody}`
+    `Auth form request body: ${authorizationRequestFormBody}`,
   );
 
   const tokenRes = await appFetch(tokenUrl, {
-    method: "POST",
+    body: authorizationRequestFormBody.toString(),
     headers: {
       "Content-Type": "application/x-www-form-urlencoded",
       DPoP: tokenRequestSignedDPop,
       "OAuth-Client-Attestation": walletInstanceAttestation,
       "OAuth-Client-Attestation-PoP": signedWiaPoP,
     },
-    body: authorizationRequestFormBody.toString(),
+    method: "POST",
   })
     .then(hasStatusOrThrow(200, IssuerResponseError))
     .then((res) => res.json())
@@ -80,7 +82,7 @@ export const authorizeAccess: IssuanceApi["authorizeAccess"] = async (
   if (!tokenRes.success) {
     Logger.log(
       LogLevel.ERROR,
-      `Token Response validation failed: ${tokenRes.error.message}`
+      `Token Response validation failed: ${tokenRes.error.message}`,
     );
 
     throw new ValidationFailed({

package/src/credential/issuance/v1.0.0/05-obtain-credential.ts

@@ -4,8 +4,12 @@ import {
   SignJWT,
 } from "@pagopa/io-react-native-jwt";
 import { v4 as uuidv4 } from "uuid";
-import { hasStatusOrThrow } from "../../../utils/misc";
+
+import type { IssuanceApi } from "../api";
+
+import { createDPopToken } from "../../../utils/dpop";
 import {
+  IoWalletError,
   IssuerResponseError,
   IssuerResponseErrorCodes,
   ResponseErrorBuilder,
@@ -13,16 +17,15 @@ import {
   UnimplementedFeatureError,
   ValidationFailed,
 } from "../../../utils/errors";
-import { createDPopToken } from "../../../utils/dpop";
-import { LogLevel, Logger } from "../../../utils/logging";
-import type { IssuanceApi } from "../api";
+import { Logger, LogLevel } from "../../../utils/logging";
+import { hasStatusOrThrow } from "../../../utils/misc";
 import { CredentialResponse, NonceResponse } from "./types";
 
 export const createNonceProof = async (
   nonce: string,
   issuer: string,
   audience: string,
-  ctx: CryptoContext
+  ctx: CryptoContext,
 ): Promise<string> => {
   const jwk = await ctx.getPublicKey();
   return new SignJWT(ctx)
@@ -30,8 +33,8 @@ export const createNonceProof = async (
       nonce,
     })
     .setProtectedHeader({
-      typ: "openid4vci-proof+jwt",
       jwk,
+      typ: "openid4vci-proof+jwt",
     })
     .setAudience(audience)
     .setIssuer(issuer)
@@ -45,11 +48,11 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
   accessToken,
   clientId,
   credentialDefinition,
-  context
+  context,
 ) => {
   const {
-    credentialCryptoContext,
     appFetch = fetch,
+    credentialCryptoContext,
     dPopCryptoContext,
   } = context;
   const { credential_configuration_id, credential_identifier } =
@@ -61,8 +64,8 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
 
   // Fetch the nonce from the Credential Issuer
   const { c_nonce } = await appFetch(nonceUrl, {
-    method: "POST",
     headers: { "Content-Type": "application/json" },
+    method: "POST",
   })
     .then(hasStatusOrThrow(200))
     .then((res) => res.json())
@@ -77,7 +80,7 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
     c_nonce,
     clientId,
     issuerUrl,
-    credentialCryptoContext
+    credentialCryptoContext,
   );
 
   Logger.log(LogLevel.DEBUG, `Signed nonce proof: ${signedNonceProof}`);
@@ -88,13 +91,13 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
       c.credential_configuration_id === credential_configuration_id &&
       (credential_identifier
         ? c.credential_identifiers.includes(credential_identifier)
-        : true)
+        : true),
   );
 
   if (!containsCredentialDefinition) {
     Logger.log(
       LogLevel.ERROR,
-      `Credential definition not found in the access token response ${accessToken.authorization_details}`
+      `Credential definition not found in the access token response ${accessToken.authorization_details}`,
     );
     throw new ValidationFailed({
       message:
@@ -120,29 +123,29 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
 
   Logger.log(
     LogLevel.DEBUG,
-    `Credential request body: ${JSON.stringify(credentialRequestFormBody)}`
+    `Credential request body: ${JSON.stringify(credentialRequestFormBody)}`,
   );
 
   const tokenRequestSignedDPop = await createDPopToken(
     {
+      ath: await sha256ToBase64(accessToken.access_token),
       htm: "POST",
       htu: credentialUrl,
       jti: `${uuidv4()}`,
-      ath: await sha256ToBase64(accessToken.access_token),
     },
-    dPopCryptoContext
+    dPopCryptoContext,
   );
 
   Logger.log(LogLevel.DEBUG, `Token request DPoP: ${tokenRequestSignedDPop}`);
 
   const credentialRes = await appFetch(credentialUrl, {
-    method: "POST",
+    body: JSON.stringify(credentialRequestFormBody),
     headers: {
+      Authorization: `${accessToken.token_type} ${accessToken.access_token}`,
       "Content-Type": "application/json",
       DPoP: tokenRequestSignedDPop,
-      Authorization: `${accessToken.token_type} ${accessToken.access_token}`,
     },
-    body: JSON.stringify(credentialRequestFormBody),
+    method: "POST",
   })
     .then(hasStatusOrThrow(200))
     .then((res) => res.json())
@@ -152,7 +155,7 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
   if (!credentialRes.success) {
     Logger.log(
       LogLevel.ERROR,
-      `Credential Response validation failed: ${credentialRes.error.message}`
+      `Credential Response validation failed: ${credentialRes.error.message}`,
     );
     throw new ValidationFailed({
       message: "Credential Response validation failed",
@@ -162,17 +165,31 @@ export const obtainCredential: IssuanceApi["obtainCredential"] = async (
 
   Logger.log(
     LogLevel.DEBUG,
-    `Credential Response: ${JSON.stringify(credentialRes.data)}`
+    `Credential Response: ${JSON.stringify(credentialRes.data)}`,
   );
 
   // Extract the format corresponding to the credential_configuration_id used
   const issuerCredentialConfig =
     issuerConf.credential_configurations_supported[credential_configuration_id];
 
+  const credential = credentialRes.data.credentials[0]?.credential;
+  if (!credential) {
+    throw new IoWalletError(
+      `No credential found in the response for credential_configuration_id ${credential_configuration_id}`,
+    );
+  }
+
+  const format = issuerCredentialConfig?.format;
+  if (!format) {
+    throw new IoWalletError(
+      `No format found for credential_configuration_id ${credential_configuration_id} in the issuer configuration`,
+    );
+  }
+
   // TODO: [SIW-2264] Handle multiple credentials
   return {
-    credential: credentialRes.data.credentials.at(0)!.credential,
-    format: issuerCredentialConfig!.format,
+    credential,
+    format,
   };
 };
 

package/src/credential/issuance/v1.0.0/06-verify-and-parse-credential.ts

@@ -1,8 +1,9 @@
+import type { IssuanceApi } from "../api";
+
 import { IoWalletError } from "../../../utils/errors";
 import { Logger, LogLevel } from "../../../utils/logging";
 import { verifyAndParseCredentialMDoc } from "../common/06-verify-and-parse-credential.mdoc";
 import { verifyAndParseCredentialSdJwt } from "../common/06-verify-and-parse-credential.sdjwt";
-import type { IssuanceApi } from "../api";
 
 export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
   async (
@@ -10,7 +11,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
     credential,
     credentialConfigurationId,
     context,
-    x509CertRoot
+    x509CertRoot,
   ) => {
     const format =
       issuerConf.credential_configurations_supported[credentialConfigurationId]
@@ -23,7 +24,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
           issuerConf,
           credential,
           credentialConfigurationId,
-          context
+          context,
         );
       }
       case "mso_mdoc": {
@@ -33,7 +34,7 @@ export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
           credential,
           credentialConfigurationId,
           context,
-          x509CertRoot
+          x509CertRoot,
         );
       }
 

package/src/credential/issuance/v1.0.0/index.ts

@@ -1,12 +1,14 @@
 import type { IssuanceApi } from "../api";
+
+import { MRTDPoPv1_0 } from "../mrtd-pop";
 import { evaluateIssuerTrust } from "./01-evaluate-issuer-trust";
 import { startUserAuthorization } from "./02-start-user-authorization";
 import {
-  continueUserAuthorizationWithMRTDPoPChallenge,
-  completePidUserAuthorizationWithQueryMode,
+  buildAuthorizationUrl,
   completeEaaUserAuthorizationWithQueryMode,
+  completePidUserAuthorizationWithQueryMode,
   completeUserAuthorizationWithFormPostJwtMode,
-  buildAuthorizationUrl,
+  continueUserAuthorizationWithMRTDPoPChallenge,
   getRequestedCredentialToBePresented,
 } from "./03-complete-user-authorization";
 import { authorizeAccess } from "./04-authorize-access";
@@ -15,20 +17,19 @@ import {
   obtainCredentialsBatch,
 } from "./05-obtain-credential";
 import { verifyAndParseCredential } from "./06-verify-and-parse-credential";
-import { MRTDPoPv1_0 } from "../mrtd-pop";
 
 export const Issuance: IssuanceApi = {
-  evaluateIssuerTrust,
-  startUserAuthorization,
+  authorizeAccess,
   buildAuthorizationUrl,
-  completePidUserAuthorizationWithQueryMode,
   completeEaaUserAuthorizationWithQueryMode,
+  completePidUserAuthorizationWithQueryMode,
+  completeUserAuthorizationWithFormPostJwtMode,
   continueUserAuthorizationWithMRTDPoPChallenge,
+  evaluateIssuerTrust,
   getRequestedCredentialToBePresented,
-  completeUserAuthorizationWithFormPostJwtMode,
-  authorizeAccess,
+  MRTDPoP: MRTDPoPv1_0,
   obtainCredential,
   obtainCredentialsBatch,
+  startUserAuthorization,
   verifyAndParseCredential,
-  MRTDPoP: MRTDPoPv1_0,
 };

package/src/credential/issuance/v1.0.0/mappers.ts

@@ -1,37 +1,38 @@
+import type { IssuerConfig } from "../api/IssuerConfig";
+
 import { CredentialIssuerEntityConfiguration } from "../../../trust/v1.0.0/types";
 import { createMapper } from "../../../utils/mappers";
-import type { IssuerConfig } from "../api/IssuerConfig";
 
 export const mapToIssuerConfig = createMapper<
   CredentialIssuerEntityConfiguration,
   IssuerConfig
 >((x) => {
   const {
+    federation_entity,
     oauth_authorization_server,
     openid_credential_issuer,
     openid_credential_verifier,
-    federation_entity,
   } = x.payload.metadata;
   return {
     authorization_endpoint: oauth_authorization_server.authorization_endpoint,
-    credential_endpoint: openid_credential_issuer.credential_endpoint,
-    credential_issuer: openid_credential_issuer.credential_issuer,
     credential_configurations_supported:
       openid_credential_issuer.credential_configurations_supported,
+    credential_endpoint: openid_credential_issuer.credential_endpoint,
+    credential_issuer: openid_credential_issuer.credential_issuer,
+    encrypted_response_enc_values_supported:
+      openid_credential_verifier?.authorization_encrypted_response_enc
+        ? [openid_credential_verifier.authorization_encrypted_response_enc]
+        : undefined,
+    federation_entity,
     keys: [
       ...openid_credential_issuer.jwks.keys,
       ...oauth_authorization_server.jwks.keys,
     ],
+    nonce_endpoint: openid_credential_issuer.nonce_endpoint,
     pushed_authorization_request_endpoint:
       oauth_authorization_server.pushed_authorization_request_endpoint,
-    token_endpoint: oauth_authorization_server.token_endpoint,
     status_assertion_endpoint:
       openid_credential_issuer.status_attestation_endpoint,
-    nonce_endpoint: openid_credential_issuer.nonce_endpoint,
-    federation_entity,
-    encrypted_response_enc_values_supported:
-      openid_credential_verifier?.authorization_encrypted_response_enc
-        ? [openid_credential_verifier.authorization_encrypted_response_enc]
-        : undefined,
+    token_endpoint: oauth_authorization_server.token_endpoint,
   };
 });

package/src/credential/issuance/v1.0.0/types.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+
 import { AuthorizationDetail, TokenResponse } from "../api/types";
 
 // Reusing the following API types because they are the same in v1.0.0
@@ -10,7 +11,7 @@ export const CredentialResponse = z.object({
   credentials: z.array(
     z.object({
       credential: z.string(),
-    })
+    }),
   ),
   notification_id: z.string().optional(),
 });