@pagopa/io-react-native-wallet 3.6.2 → 3.6.4

package/src/credential/issuance/v1.0.0/01-evaluate-issuer-trust.ts

@@ -1,10 +1,11 @@
-import { getCredentialIssuerEntityConfiguration } from "../../../trust/v1.0.0/entities";
 import type { IssuanceApi } from "../api";
+
+import { getCredentialIssuerEntityConfiguration } from "../../../trust/v1.0.0/entities";
 import { mapToIssuerConfig } from "./mappers";
 
 export const evaluateIssuerTrust: IssuanceApi["evaluateIssuerTrust"] = async (
   issuerUrl,
-  context = {}
+  context = {},
 ) => {
   const issuerConf = await getCredentialIssuerEntityConfiguration(issuerUrl, {
     appFetch: context.appFetch,

package/src/credential/issuance/v1.0.0/02-start-user-authorization.ts

@@ -1,8 +1,9 @@
+import type { IssuanceApi } from "../api";
+
+import { IoWalletError } from "../../../utils/errors";
+import { Logger, LogLevel } from "../../../utils/logging";
 import { generateRandomAlphaNumericString } from "../../../utils/misc";
 import { makeParRequest } from "../../../utils/par";
-import { LogLevel, Logger } from "../../../utils/logging";
-import { IoWalletError } from "../../../utils/errors";
-import type { IssuanceApi } from "../api";
 import {
   selectCredentialDefinition,
   selectResponseMode,
@@ -11,10 +12,10 @@ import {
 export const startUserAuthorization: IssuanceApi["startUserAuthorization"] =
   async (issuerConf, credentialIds, proof, ctx) => {
     const {
-      wiaCryptoContext,
-      walletInstanceAttestation,
-      redirectUri,
       appFetch = fetch,
+      redirectUri,
+      walletInstanceAttestation,
+      wiaCryptoContext,
     } = ctx;
 
     const clientId = await wiaCryptoContext.getPublicKey().then((_) => _.kid);
@@ -22,7 +23,7 @@ export const startUserAuthorization: IssuanceApi["startUserAuthorization"] =
     if (!clientId) {
       Logger.log(
         LogLevel.ERROR,
-        `Public key associated with kid ${clientId} not found in the device`
+        `Public key associated with kid ${clientId} not found in the device`,
       );
       throw new IoWalletError("No public key found");
     }
@@ -30,10 +31,10 @@ export const startUserAuthorization: IssuanceApi["startUserAuthorization"] =
     const parEndpoint = issuerConf.pushed_authorization_request_endpoint;
     const aud = issuerConf.credential_issuer;
     const responseMode = selectResponseMode(issuerConf, credentialIds);
-    const getPar = makeParRequest({ wiaCryptoContext, appFetch });
+    const getPar = makeParRequest({ appFetch, wiaCryptoContext });
 
     const credentialDefinition = credentialIds.map((c) =>
-      selectCredentialDefinition(issuerConf, c)
+      selectCredentialDefinition(issuerConf, c),
     );
 
     if (proof.proofType === "mrtd-pop") {
@@ -44,10 +45,10 @@ export const startUserAuthorization: IssuanceApi["startUserAuthorization"] =
        * See https://italia.github.io/eid-wallet-it-docs/versione-corrente/en/credential-issuance-endpoint.html#pushed-authorization-request-endpoint
        */
       credentialDefinition.push({
-        type: "it_l2+document_proof",
-        idphinting: proof.idpHinting,
         challenge_method: "mrtd+ias",
         challenge_redirect_uri: redirectUri,
+        idphinting: proof.idpHinting,
+        type: "it_l2+document_proof",
       });
     }
 
@@ -56,19 +57,19 @@ export const startUserAuthorization: IssuanceApi["startUserAuthorization"] =
       walletInstanceAttestation,
       {
         aud,
+        authorizationDetails: credentialDefinition,
         clientId,
         codeVerifier,
         redirectUri,
         responseMode,
-        authorizationDetails: credentialDefinition,
-      }
+      },
     );
 
     return {
-      issuerRequestUri,
       clientId,
       codeVerifier,
       credentialDefinition,
+      issuerRequestUri,
       responseMode,
     };
   };

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,
         );
       }