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

package/src/credential/issuance/common/06-verify-and-parse-credential.mdoc.ts

@@ -1,28 +1,30 @@
+import type { PublicKey } from "@pagopa/io-react-native-crypto";
 import type { CBOR } from "@pagopa/io-react-native-iso18013";
 import type { CryptoContext } from "@pagopa/io-react-native-jwt";
-import type { PublicKey } from "@pagopa/io-react-native-crypto";
+
+import type { Out } from "../../../utils/misc";
+import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
+
 import {
   getParsedCredentialClaimKey,
   verify as verifyMdoc,
 } from "../../../mdoc";
 import { IoWalletError } from "../../../utils/errors";
-import type { Out } from "../../../utils/misc";
 import { isSameThumbprint } from "../../../utils/jwk";
-import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
+
+type ClaimConfig = CredentialConf["claims"][number];
 
 type CredentialConf =
   IssuerConfig["credential_configurations_supported"][string];
 
-type ClaimConfig = CredentialConf["claims"][number];
+type DecodedMDocCredential = Out<typeof verifyMdoc> & {
+  issuerSigned: CBOR.IssuerSigned;
+};
 
 type DisplayableClaim = Omit<ClaimConfig, "display"> & {
   display: NonNullable<ClaimConfig["display"]>;
 };
 
-type DecodedMDocCredential = Out<typeof verifyMdoc> & {
-  issuerSigned: CBOR.IssuerSigned;
-};
-
 /**
  * Given a credential, verify it's in the supported format
  * and the credential is correctly signed
@@ -40,7 +42,7 @@ type DecodedMDocCredential = Out<typeof verifyMdoc> & {
 async function verifyCredentialMDoc(
   rawCredential: string,
   x509CertRoot: string,
-  holderBindingContext: CryptoContext
+  holderBindingContext: CryptoContext,
 ): Promise<DecodedMDocCredential> {
   const [decodedCredential, holderBindingKey] =
     // parallel for optimization
@@ -58,7 +60,7 @@ async function verifyCredentialMDoc(
 
   if (!(await isSameThumbprint(key, holderBindingKey as PublicKey))) {
     throw new IoWalletError(
-      `Failed to verify holder binding, holder binding key and mDoc deviceKey don't match`
+      `Failed to verify holder binding, holder binding key and mDoc deviceKey don't match`,
     );
   }
 
@@ -70,8 +72,8 @@ const parseCredentialMDoc = (
   credentialConfig: CredentialConf,
   // credential_type: string,
   { issuerSigned }: DecodedMDocCredential,
-  ignoreMissingAttributes: boolean = false,
-  includeUndefinedAttributes: boolean = false
+  ignoreMissingAttributes = false,
+  includeUndefinedAttributes = false,
 ): ParsedCredential => {
   if (!credentialConfig) {
     throw new IoWalletError("Credential type not supported by the issuer");
@@ -84,12 +86,12 @@ const parseCredentialMDoc = (
   // Claims without display property (such as `iat`, `exp`, `iss`, etc.)
   // must be ignored as they are not meant to be displayed to the user.
   const displayableClaims = credentialConfig.claims.filter(
-    (c) => c.display !== undefined
+    (c) => c.display !== undefined,
   ) as DisplayableClaim[];
 
   const attrDefinitions = displayableClaims.map<
-    [string, string, { name: string; locale: string }[]]
-  >(({ path: [namespace, attribute], display }) => [
+    [string, string, { locale: string; name: string }[]]
+  >(({ display, path: [namespace, attribute] }) => [
     namespace as string,
     attribute as string,
     display,
@@ -105,7 +107,7 @@ const parseCredentialMDoc = (
         namespace,
         v.elementIdentifier,
         v.elementValue,
-      ])
+      ]),
   );
 
   // Check that all mandatory attributes defined in the issuer configuration are present in the disclosure set
@@ -114,8 +116,8 @@ const parseCredentialMDoc = (
     ([attrDefNamespace, attrKey]) =>
       !flatNamespaces.some(
         ([namespace, claim]) =>
-          attrDefNamespace === namespace && attrKey === claim
-      )
+          attrDefNamespace === namespace && attrKey === claim,
+      ),
   );
 
   if (attrsNotInDisclosures.length > 0) {
@@ -126,7 +128,7 @@ const parseCredentialMDoc = (
 
     if (!ignoreMissingAttributes) {
       throw new IoWalletError(
-        `Some attributes are missing in the credential. Missing: [${missing}], received: [${received}]`
+        `Some attributes are missing in the credential. Missing: [${missing}], received: [${received}]`,
       );
     }
   }
@@ -143,10 +145,10 @@ const parseCredentialMDoc = (
             display,
             value: flatNamespaces.find(
               ([namespace, name]) =>
-                attrDefNamespace === namespace && name === attrKey
+                attrDefNamespace === namespace && name === attrKey,
             )?.[2],
           },
-        ] as const
+        ] as const,
     )
     //filter the not found elements
     .filter(([_, __, definition]) => definition.value !== undefined)
@@ -156,17 +158,17 @@ const parseCredentialMDoc = (
       (acc, [attrDefNamespace, attrKey, { display, value }]) => ({
         ...acc,
         [getParsedCredentialClaimKey(attrDefNamespace, attrKey)]: {
-          value,
           name: display.reduce(
             (names, { locale, name }) => ({
               ...names,
               [locale]: name,
             }),
-            {}
+            {},
           ),
+          value,
         },
       }),
-      {}
+      {},
     );
 
   if (includeUndefinedAttributes) {
@@ -174,12 +176,12 @@ const parseCredentialMDoc = (
       Object.values(flatNamespaces)
         .filter(
           ([namespace, key]) =>
-            !definedValues[getParsedCredentialClaimKey(namespace, key)]
+            !definedValues[getParsedCredentialClaimKey(namespace, key)],
         )
         .map(([namespace, key, value]) => [
           getParsedCredentialClaimKey(namespace, key),
-          { value, name: key },
-        ])
+          { name: key, value },
+        ]),
     );
     return {
       ...definedValues,
@@ -200,7 +202,7 @@ export const verifyAndParseCredentialMDoc: IssuanceApi["verifyAndParseCredential
       ignoreMissingAttributes,
       includeUndefinedAttributes,
     },
-    x509CertRoot
+    x509CertRoot,
   ) => {
     if (!x509CertRoot) {
       throw new IoWalletError("Missing x509CertRoot");
@@ -209,28 +211,31 @@ export const verifyAndParseCredentialMDoc: IssuanceApi["verifyAndParseCredential
     const decoded = await verifyCredentialMDoc(
       credential,
       x509CertRoot,
-      credentialCryptoContext
+      credentialCryptoContext,
     );
 
     const credentialConfig =
-      issuerConf.credential_configurations_supported[
-        credentialConfigurationId
-      ]!;
+      issuerConf.credential_configurations_supported[credentialConfigurationId];
+    if (!credentialConfig) {
+      throw new IoWalletError(
+        `Missing credential configuration for ${credentialConfigurationId}`,
+      );
+    }
     const parsedCredential = parseCredentialMDoc(
       credentialConfig,
       decoded,
       ignoreMissingAttributes,
-      includeUndefinedAttributes
+      includeUndefinedAttributes,
     );
 
     const { signed, validUntil } =
       decoded.issuerSigned.issuerAuth.payload.validityInfo;
 
     return {
-      parsedCredential,
       credential,
       credentialConfigurationId,
       expiration: validUntil,
       issuedAt: signed,
+      parsedCredential,
     };
   };

package/src/credential/issuance/common/06-verify-and-parse-credential.sdjwt.ts

@@ -1,25 +1,28 @@
+import type { Verifier } from "@sd-jwt/types";
+
 import {
   type CryptoContext,
   verify as verifyJwt,
 } from "@pagopa/io-react-native-jwt";
-import { type SDJwt, type VerifierOptions, SDJwtInstance } from "@sd-jwt/core";
+import { type SDJwt, SDJwtInstance, type VerifierOptions } from "@sd-jwt/core";
 import { digest } from "@sd-jwt/crypto-nodejs";
-import type { Verifier } from "@sd-jwt/types";
-import { isPathEqual, isPrefixOf } from "../../../utils/parser";
-import { IoWalletError } from "../../../utils/errors";
-import { LogLevel, Logger } from "../../../utils/logging";
-import { isSameThumbprint, type JWK } from "../../../utils/jwk";
+
 import type { SdJwt4VCBase } from "../../../sd-jwt/types";
+import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
+
+import { MissingX509CertsError } from "../../../trust/common/errors";
 import { fixLegacyCredentialSdJwt } from "../../../utils/credentials";
+import { IoWalletError } from "../../../utils/errors";
+import { isSameThumbprint, type JWK } from "../../../utils/jwk";
+import { Logger, LogLevel } from "../../../utils/logging";
+import { isPathEqual, isPrefixOf } from "../../../utils/parser";
 import { verifyX509Chain } from "../../../utils/x509";
-import { MissingX509CertsError } from "../../../trust/common/errors";
-import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
+
+type ClaimConfig = CredentialConf["claims"][number];
 
 type CredentialConf =
   IssuerConfig["credential_configurations_supported"][string];
 
-type ClaimConfig = CredentialConf["claims"][number];
-
 type DisplayableClaim = Omit<ClaimConfig, "display"> & {
   display: NonNullable<ClaimConfig["display"]>;
 };
@@ -35,13 +38,13 @@ type DisplayableClaim = Omit<ClaimConfig, "display"> & {
 const parseCredentialSdJwt = (
   credentialConfig: CredentialConf,
   parsedCredentialRaw: Record<string, unknown>,
-  ignoreMissingAttributes: boolean = false,
-  includeUndefinedAttributes: boolean = false
+  ignoreMissingAttributes = false,
+  includeUndefinedAttributes = false,
 ): ParsedCredential => {
   // Claims without display property (such as `iat`, `exp`, `iss`, etc.)
   // must be ignored as they are not meant to be displayed to the user.
   const displayableClaims = (credentialConfig.claims || []).filter(
-    (c) => c.display !== undefined
+    (c) => c.display !== undefined,
   ) as DisplayableClaim[];
 
   // Check that all mandatory attributes defined in the issuer configuration are present in the credential
@@ -50,7 +53,7 @@ const parseCredentialSdJwt = (
     const rootKeysToVerify = new Set(
       displayableClaims
         .map((c) => c.path[0])
-        .filter((p): p is string => typeof p === "string")
+        .filter((p): p is string => typeof p === "string"),
     );
 
     for (const rootKey of rootKeysToVerify) {
@@ -63,7 +66,7 @@ const parseCredentialSdJwt = (
       const missing = missingPaths.join(", ");
       const received = Object.keys(parsedCredentialRaw).join(", ");
       throw new IoWalletError(
-        `Some attributes are missing in the credential. Missing: [${missing}], received: [${received}]`
+        `Some attributes are missing in the credential. Missing: [${missing}], received: [${received}]`,
       );
     }
   }
@@ -72,7 +75,7 @@ const parseCredentialSdJwt = (
    * Helper to find display metadata for any given path
    */
   const getDisplayNames = (
-    path: (string | number | null)[]
+    path: (null | number | string)[],
   ): Record<string, string> | undefined => {
     const match = displayableClaims.find((c) => isPathEqual(c.path, path));
     if (!match) return undefined;
@@ -89,12 +92,12 @@ const parseCredentialSdJwt = (
    */
   const processLevel = (
     currentData: unknown,
-    currentPath: (string | number | null)[]
+    currentPath: (null | number | string)[],
   ): unknown => {
     // Handle Arrays
     if (Array.isArray(currentData)) {
       return currentData.map((item) =>
-        processLevel(item, [...currentPath, null])
+        processLevel(item, [...currentPath, null]),
       );
     }
 
@@ -105,10 +108,10 @@ const parseCredentialSdJwt = (
 
     const dataObj = currentData as Record<string, unknown>;
     const result: ParsedCredential = {};
-    const processedKeys = new Set<string | number>();
+    const processedKeys = new Set<number | string>();
 
     // Identify unique keys in config at this level
-    const configKeysAtThisLevel: (string | number)[] = [];
+    const configKeysAtThisLevel: (number | string)[] = [];
     for (const claim of displayableClaims) {
       // Check if the claim path starts with the current path
       if (isPrefixOf(currentPath, claim.path)) {
@@ -173,7 +176,7 @@ type SdJwtInstanceVerifier = Verifier<VerifierOptions & { issuerKeys: JWK[] }>;
 const sdJwtInstanceVerifier: SdJwtInstanceVerifier = async (
   data,
   signature,
-  options
+  options,
 ) => {
   if (!options?.issuerKeys) {
     return false;
@@ -206,7 +209,7 @@ const sdJwtInstanceVerifier: SdJwtInstanceVerifier = async (
 async function verifyCredentialSdJwt(
   rawCredential: string,
   issuerKeys: JWK[],
-  holderBindingContext: CryptoContext
+  holderBindingContext: CryptoContext,
 ): Promise<SDJwt> {
   const sdJwtInstance = new SDJwtInstance({
     hasher: digest,
@@ -239,17 +242,17 @@ export const verifyAndParseCredentialSdJwt: IssuanceApi["verifyAndParseCredentia
       includeUndefinedAttributes,
       validateCertificateChain,
     },
-    x509CertRoot
+    x509CertRoot,
   ) => {
     const decoded = await verifyCredentialSdJwt(
       credential,
       issuerConf.keys,
-      credentialCryptoContext
+      credentialCryptoContext,
     );
 
     Logger.log(
       LogLevel.DEBUG,
-      `Decoded credential: ${JSON.stringify(decoded)}`
+      `Decoded credential: ${JSON.stringify(decoded)}`,
     );
 
     if (validateCertificateChain) {
@@ -269,7 +272,7 @@ export const verifyAndParseCredentialSdJwt: IssuanceApi["verifyAndParseCredentia
     if (!credentialConfig) {
       Logger.log(
         LogLevel.ERROR,
-        `Credential type not supported by the issuer: ${credentialConfigurationId}`
+        `Credential type not supported by the issuer: ${credentialConfigurationId}`,
       );
       throw new IoWalletError("Credential type not supported by the issuer");
     }
@@ -283,7 +286,7 @@ export const verifyAndParseCredentialSdJwt: IssuanceApi["verifyAndParseCredentia
       credentialConfig,
       parsedCredentialRaw,
       ignoreMissingAttributes,
-      includeUndefinedAttributes
+      includeUndefinedAttributes,
     );
 
     const issuedAt =
@@ -298,12 +301,12 @@ export const verifyAndParseCredentialSdJwt: IssuanceApi["verifyAndParseCredentia
 
     Logger.log(
       LogLevel.DEBUG,
-      `Parsed credential: ${JSON.stringify(parsedCredential)}\nIssued at: ${issuedAt}`
+      `Parsed credential: ${JSON.stringify(parsedCredential)}\nIssued at: ${issuedAt}`,
     );
 
     return {
-      parsedCredential,
       expiration,
       issuedAt,
+      parsedCredential,
     };
   };

package/src/credential/issuance/common/errors.ts

@@ -5,10 +5,6 @@ import { IoWalletError, serializeAttrs } from "../../../utils/errors";
  */
 export class AuthorizationError extends IoWalletError {
   code = "ERR_IO_WALLET_AUTHORIZATION_ERROR";
-
-  constructor(message?: string) {
-    super(message);
-  }
 }
 
 /**

package/src/credential/issuance/mrtd-pop/01-verify-and-parse-challenge-info.ts

@@ -1,24 +1,26 @@
 import { verifyMrtdChallenge } from "@pagopa/io-wallet-oauth2";
-import { IoWalletError } from "../../../utils/errors";
-import { createVerifyJwtFromJwks } from "../../../utils/callbacks";
+
 import type { MRTDPoPApi } from "../api/mrtd-pop";
 
+import { createVerifyJwtFromJwks } from "../../../utils/callbacks";
+import { IoWalletError } from "../../../utils/errors";
+
 export const verifyAndParseChallengeInfo: MRTDPoPApi["verifyAndParseChallengeInfo"] =
   async (issuerConf, challengeInfoJwt, { wiaCryptoContext }) => {
     const clientId = await wiaCryptoContext.getPublicKey().then((x) => x.kid);
 
     if (!clientId) {
       throw new IoWalletError(
-        "Could not extract client_id from Wallet Attestation"
+        "Could not extract client_id from Wallet Attestation",
       );
     }
 
     const verified = await verifyMrtdChallenge({
-      challengeJwt: challengeInfoJwt,
-      clientId,
       callbacks: {
         verifyJwt: createVerifyJwtFromJwks(issuerConf.keys),
       },
+      challengeJwt: challengeInfoJwt,
+      clientId,
     });
 
     return verified.payload;

package/src/credential/issuance/mrtd-pop/02-init-challenge.ts

@@ -6,22 +6,24 @@ import {
   IoWalletSdkConfig,
   UnexpectedStatusCodeError as SdkUnexpectedStatusCodeError,
 } from "@pagopa/io-wallet-utils";
-import { Logger, LogLevel } from "../../../utils/logging";
-import {
-  IssuerResponseError,
-  IssuerResponseErrorCodes,
-  ResponseErrorBuilder,
-} from "../../../utils/errors";
+
 import type { MRTDPoPApi } from "../api/mrtd-pop";
+
 import {
   createSignJwtFromCryptoContext,
   createVerifyJwtFromJwks,
   partialCallbacks,
 } from "../../../utils/callbacks";
+import {
+  IssuerResponseError,
+  IssuerResponseErrorCodes,
+  ResponseErrorBuilder,
+} from "../../../utils/errors";
+import { Logger, LogLevel } from "../../../utils/logging";
 
-type Config = {
+interface Config {
   sdkConfig: IoWalletSdkConfig;
-};
+}
 
 /**
  * Factory function to create `initChallenge` for MRTD PoP flow.
@@ -30,14 +32,14 @@ type Config = {
  * @returns `initChallenge` function compliant with the public API
  */
 export function createInitChallenge(
-  config: Config
+  config: Config,
 ): MRTDPoPApi["initChallenge"] {
   return async function initChallenge(
     issuerConf,
     initUrl,
     mrtd_auth_session,
     mrtd_pop_jwt_nonce,
-    context
+    context,
   ) {
     const {
       appFetch = fetch,
@@ -46,37 +48,37 @@ export function createInitChallenge(
     } = context;
 
     const clientAttestationDPoP = await createClientAttestationPopJwt({
-      config: config.sdkConfig,
+      authorizationServer: issuerConf.credential_issuer,
       callbacks: {
         generateRandom: partialCallbacks.generateRandom,
         signJwt: createSignJwtFromCryptoContext(wiaCryptoContext),
       },
       clientAttestation: walletInstanceAttestation,
-      authorizationServer: issuerConf.credential_issuer,
+      config: config.sdkConfig,
       signer: {
-        method: "jwk",
         alg: "ES256",
+        method: "jwk",
         publicJwk: await wiaCryptoContext.getPublicKey(),
       },
     });
 
     const initResult = await fetchMrtdPopInit({
-      popInitEndpoint: initUrl,
-      mrtdAuthSession: mrtd_auth_session,
-      mrtdPopJwtNonce: mrtd_pop_jwt_nonce,
-      walletAttestation: walletInstanceAttestation,
-      clientAttestationDPoP,
       callbacks: {
-        verifyJwt: createVerifyJwtFromJwks(issuerConf.keys),
         fetch: appFetch,
+        verifyJwt: createVerifyJwtFromJwks(issuerConf.keys),
       },
+      clientAttestationDPoP,
+      mrtdAuthSession: mrtd_auth_session,
+      mrtdPopJwtNonce: mrtd_pop_jwt_nonce,
+      popInitEndpoint: initUrl,
+      walletAttestation: walletInstanceAttestation,
     }).catch(handleInitChallengeError);
 
     return {
       challenge: initResult.challenge,
       mrtd_pop_nonce: initResult.mrtdPopNonce,
-      pop_verify_endpoint: initResult.popVerifyEndpoint,
       mrz: initResult.mrz,
+      pop_verify_endpoint: initResult.popVerifyEndpoint,
     };
   };
 }

package/src/credential/issuance/mrtd-pop/03-validate-challenge.ts

@@ -1,19 +1,22 @@
+import type { IoWalletSdkConfig } from "@pagopa/io-wallet-utils";
+
 import { SignJWT } from "@pagopa/io-react-native-jwt";
 import {
   createClientAttestationPopJwt,
   fetchMrtdPopVerify,
 } from "@pagopa/io-wallet-oauth2";
-import type { IoWalletSdkConfig } from "@pagopa/io-wallet-utils";
-import { sdkUnexpectedStatusCodeToIssuerError } from "../../../utils/errors";
+
+import type { MRTDPoPApi } from "../api/mrtd-pop";
+
 import {
   createSignJwtFromCryptoContext,
   partialCallbacks,
 } from "../../../utils/callbacks";
-import type { MRTDPoPApi } from "../api/mrtd-pop";
+import { sdkUnexpectedStatusCodeToIssuerError } from "../../../utils/errors";
 
-type Config = {
+interface Config {
   sdkConfig: IoWalletSdkConfig;
-};
+}
 
 /**
  * Factory function to create `validateChallenge` for MRTD PoP flow.
@@ -22,7 +25,7 @@ type Config = {
  * @returns `validateChallenge` function compliant with the public API
  */
 export function createValidateChallenge(
-  config: Config
+  config: Config,
 ): MRTDPoPApi["validateChallenge"] {
   return async function validateChallenge(
     issuerConf,
@@ -31,7 +34,7 @@ export function createValidateChallenge(
     mrtd_pop_nonce,
     mrtd,
     ias,
-    context
+    context,
   ) {
     const {
       appFetch = fetch,
@@ -44,52 +47,52 @@ export function createValidateChallenge(
     const wiaPublicJwk = await wiaCryptoContext.getPublicKey();
 
     const clientAttestationDPoP = await createClientAttestationPopJwt({
-      config: config.sdkConfig,
+      authorizationServer: aud,
       callbacks: {
         generateRandom: partialCallbacks.generateRandom,
         signJwt: createSignJwtFromCryptoContext(wiaCryptoContext),
       },
       clientAttestation: walletInstanceAttestation,
-      authorizationServer: aud,
+      config: config.sdkConfig,
       signer: {
-        method: "jwk",
         alg: "ES256",
+        method: "jwk",
         publicJwk: wiaPublicJwk,
       },
     });
 
     const mrtdValidationJwt = await new SignJWT(wiaCryptoContext)
       .setProtectedHeader({
-        typ: "mrtd-ias+jwt",
         kid: wiaPublicJwk.kid,
+        typ: "mrtd-ias+jwt",
       })
       .setPayload({
-        iss: wiaPublicJwk.kid,
         aud,
         document_type: "cie",
-        mrtd,
         ias,
+        iss: wiaPublicJwk.kid,
+        mrtd,
       })
       .setIssuedAt()
       .setExpirationTime("5m")
       .sign();
 
     const verifyResult = await fetchMrtdPopVerify({
-      popVerifyEndpoint: verifyUrl,
-      mrtdAuthSession: mrtd_auth_session,
-      mrtdPopNonce: mrtd_pop_nonce,
-      clientAttestationDPoP,
-      mrtdValidationJwt,
-      walletAttestation: walletInstanceAttestation,
       callbacks: {
         fetch: appFetch,
         ...partialCallbacks,
       },
+      clientAttestationDPoP,
+      mrtdAuthSession: mrtd_auth_session,
+      mrtdPopNonce: mrtd_pop_nonce,
+      mrtdValidationJwt,
+      popVerifyEndpoint: verifyUrl,
+      walletAttestation: walletInstanceAttestation,
     }).catch(sdkUnexpectedStatusCodeToIssuerError);
 
     return {
-      redirect_uri: verifyResult.redirectUri,
       mrtd_val_pop_nonce: verifyResult.mrtdValPopNonce,
+      redirect_uri: verifyResult.redirectUri,
     };
   };
 }
@@ -97,8 +100,8 @@ export function createValidateChallenge(
 export const buildChallengeCallbackUrl: MRTDPoPApi["buildChallengeCallbackUrl"] =
   async (redirectUri, valPopNonce, authSession) => {
     const params = new URLSearchParams({
-      mrtd_val_pop_nonce: valPopNonce,
       mrtd_auth_session: authSession,
+      mrtd_val_pop_nonce: valPopNonce,
     });
 
     const callbackUrl = `${redirectUri}?${params}`;

package/src/credential/issuance/mrtd-pop/index.ts

@@ -1,22 +1,23 @@
-import { sdkConfigV1_0, sdkConfigV1_3 } from "../../../utils/config";
 import type { MRTDPoPApi } from "../api/mrtd-pop";
+
+import { sdkConfigV1_0, sdkConfigV1_3 } from "../../../utils/config";
 import { verifyAndParseChallengeInfo } from "./01-verify-and-parse-challenge-info";
 import { createInitChallenge } from "./02-init-challenge";
 import {
-  createValidateChallenge,
   buildChallengeCallbackUrl,
+  createValidateChallenge,
 } from "./03-validate-challenge";
 
 export const MRTDPoPv1_0: MRTDPoPApi = {
-  verifyAndParseChallengeInfo,
+  buildChallengeCallbackUrl,
   initChallenge: createInitChallenge({ sdkConfig: sdkConfigV1_0 }),
   validateChallenge: createValidateChallenge({ sdkConfig: sdkConfigV1_0 }),
-  buildChallengeCallbackUrl,
+  verifyAndParseChallengeInfo,
 };
 
 export const MRTDPoPv1_3: MRTDPoPApi = {
-  verifyAndParseChallengeInfo,
+  buildChallengeCallbackUrl,
   initChallenge: createInitChallenge({ sdkConfig: sdkConfigV1_3 }),
   validateChallenge: createValidateChallenge({ sdkConfig: sdkConfigV1_3 }),
-  buildChallengeCallbackUrl,
+  verifyAndParseChallengeInfo,
 };