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

package/src/credential/status/v1.3.3/03-get-status.ts

@@ -1,7 +1,9 @@
 import { StatusList as JwtStatusList } from "@sd-jwt/jwt-status-list";
-import { IoWalletError } from "../../../utils/errors";
+
 import type { StatusListApi } from "../api/status-list";
 
+import { IoWalletError } from "../../../utils/errors";
+
 /**
  * Mapping of status bits to their corresponding meaning as defined in the specification.
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/credential-revocation.html#token-status-lists
@@ -22,19 +24,19 @@ const formatStatusBit = (statusBit: number) =>
 export const getStatus: StatusListApi["getStatus"] = (statusList, idx) => {
   const decodedStatusList = JwtStatusList.decompressStatusList(
     statusList.lst,
-    statusList.bits
+    statusList.bits,
   );
   const statusBit = decodedStatusList.getStatus(idx) as CredentialStatusBit;
   const status = CredentialStatusMap[statusBit];
 
   if (!status) {
     throw new IoWalletError(
-      `Unsupported credential status bit: ${formatStatusBit(statusBit)}`
+      `Unsupported credential status bit: ${formatStatusBit(statusBit)}`,
     );
   }
 
   return {
-    status,
     rawStatus: formatStatusBit(statusBit),
+    status,
   };
 };

package/src/credential/status/v1.3.3/index.ts

@@ -1,4 +1,5 @@
 import type { CredentialStatusApi } from "../api";
+
 import {
   getStatusList,
   getStatusListByUri,
@@ -12,11 +13,11 @@ export const CredentialStatus: CredentialStatusApi = {
     isSupported: false,
   },
   statusList: {
-    isSupported: true,
     get: getStatusList,
     getByUri: getStatusListByUri,
-    verifyAndParse: verifyAndParseStatusList,
     getStatus,
     getStatusListEntry,
+    isSupported: true,
+    verifyAndParse: verifyAndParseStatusList,
   },
 };

package/src/credential/trustmark/api/index.ts

@@ -1,14 +1,6 @@
 import type { CryptoContext } from "@pagopa/io-react-native-jwt";
 
 export type GetCredentialTrustmarkJwt = (params: {
-  /**
-   * The Wallet Instance's attestation
-   */
-  walletInstanceAttestation: string;
-  /**
-   * The Wallet Instance's crypto context associated with the walletInstanceAttestation parameter
-   */
-  wiaCryptoContext: CryptoContext;
   /**
    * The type of credential for which the trustmark is generated
    */
@@ -23,15 +15,23 @@ export type GetCredentialTrustmarkJwt = (params: {
    * If a string is provided, it is interpreted as a time span and added to the current timestamp.
    */
   expirationTime?: number | string;
-}) => Promise<{
   /**
-   * The signed JWT
+   * The Wallet Instance's attestation
    */
-  jwt: string;
+  walletInstanceAttestation: string;
+  /**
+   * The Wallet Instance's crypto context associated with the walletInstanceAttestation parameter
+   */
+  wiaCryptoContext: CryptoContext;
+}) => Promise<{
   /**
    * The expiration time of the JWT in seconds
    */
   expirationTime: number;
+  /**
+   * The signed JWT
+   */
+  jwt: string;
 }>;
 
 export interface TrustmarkApi {

package/src/credential/trustmark/v1.0.0/get-credential-trustmark.ts

@@ -1,32 +1,33 @@
 import {
+  decode as decodeJwt,
   SignJWT,
   thumbprint,
-  decode as decodeJwt,
 } from "@pagopa/io-react-native-jwt";
-import { type TrustmarkApi as Api } from "../api";
-import * as WalletInstanceAttestation from "../../../wallet-instance-attestation/v1.0.0/utils";
+
 import { IoWalletError } from "../../../utils/errors";
+import { Logger, LogLevel } from "../../../utils/logging";
 import { obfuscateString } from "../../../utils/string";
-import { LogLevel, Logger } from "../../../utils/logging";
+import * as WalletInstanceAttestation from "../../../wallet-instance-attestation/v1.0.0/utils";
+import { type TrustmarkApi as Api } from "../api";
 
 export const getCredentialTrustmark: Api["getCredentialTrustmark"] = async ({
-  walletInstanceAttestation,
-  wiaCryptoContext,
   credentialType,
   docNumber,
   expirationTime = "2m",
+  walletInstanceAttestation,
+  wiaCryptoContext,
 }) => {
   /**
    * Check that the public key used to sign the trustmark is the one used for the WIA
    */
   const holderBindingKey = await wiaCryptoContext.getPublicKey();
   const decodedWia = WalletInstanceAttestation.decode(
-    walletInstanceAttestation
+    walletInstanceAttestation,
   );
 
   Logger.log(
     LogLevel.DEBUG,
-    `Decoded wia ${JSON.stringify(decodedWia.payload)} with holder binding key ${JSON.stringify(holderBindingKey)}`
+    `Decoded wia ${JSON.stringify(decodedWia.payload)} with holder binding key ${JSON.stringify(holderBindingKey)}`,
   );
 
   /**
@@ -35,7 +36,7 @@ export const getCredentialTrustmark: Api["getCredentialTrustmark"] = async ({
   if (decodedWia.payload.exp * 1000 < Date.now()) {
     Logger.log(
       LogLevel.ERROR,
-      `Wallet Instance Attestation expired with exp: ${decodedWia.payload.exp}`
+      `Wallet Instance Attestation expired with exp: ${decodedWia.payload.exp}`,
     );
     throw new IoWalletError("Wallet Instance Attestation expired");
   }
@@ -49,16 +50,16 @@ export const getCredentialTrustmark: Api["getCredentialTrustmark"] = async ({
   if (wiaThumbprint !== cryptoContextThumbprint) {
     Logger.log(
       LogLevel.ERROR,
-      `Failed to verify holder binding for status attestation, expected thumbprint: ${cryptoContextThumbprint}, got: ${wiaThumbprint}`
+      `Failed to verify holder binding for status attestation, expected thumbprint: ${cryptoContextThumbprint}, got: ${wiaThumbprint}`,
     );
     throw new IoWalletError(
-      `Failed to verify holder binding for status attestation, expected thumbprint: ${cryptoContextThumbprint}, got: ${wiaThumbprint}`
+      `Failed to verify holder binding for status attestation, expected thumbprint: ${cryptoContextThumbprint}, got: ${wiaThumbprint}`,
     );
   }
 
   Logger.log(
     LogLevel.DEBUG,
-    `Wia thumbprint: ${wiaThumbprint} CryptoContext thumbprint: ${cryptoContextThumbprint}`
+    `Wia thumbprint: ${wiaThumbprint} CryptoContext thumbprint: ${cryptoContextThumbprint}`,
   );
 
   /**
@@ -83,7 +84,7 @@ export const getCredentialTrustmark: Api["getCredentialTrustmark"] = async ({
   const decodedTrustmark = decodeJwt(signedTrustmarkJwt);
 
   return {
-    jwt: signedTrustmarkJwt,
     expirationTime: decodedTrustmark.payload.exp ?? 0,
+    jwt: signedTrustmarkJwt,
   };
 };

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

@@ -1,6 +1,7 @@
-import { getCredentialTrustmark } from "./get-credential-trustmark";
 import type { TrustmarkApi } from "../api";
 
+import { getCredentialTrustmark } from "./get-credential-trustmark";
+
 export const Trustmark: TrustmarkApi = {
   getCredentialTrustmark,
 };

package/src/credential/trustmark/v1.3.3/index.ts

@@ -1,6 +1,7 @@
-import { getCredentialTrustmark } from "./get-credential-trustmark";
 import type { TrustmarkApi } from "../api";
 
+import { getCredentialTrustmark } from "./get-credential-trustmark";
+
 export const Trustmark: TrustmarkApi = {
   getCredentialTrustmark,
 };

package/src/credentials-catalogue/api/DigitalCredentialsCatalogue.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+
 import { UnixTime } from "../../utils/zod";
 
 export const LocalizationInfo = z.object({
@@ -7,61 +8,62 @@ export const LocalizationInfo = z.object({
   default_locale: z.string(),
   version: z.string(),
 });
-export type LocalizationInfo = z.infer<typeof LocalizationInfo>;
-
 /**
  * Merged translations for one or more locales, keyed by locale code.
  * Each locale maps l10n_id keys to their translated string values.
  */
 export type CatalogueTranslations = Record<string, Record<string, string>>;
 
+export type LocalizationInfo = z.infer<typeof LocalizationInfo>;
+
 const AdministrativeExpirationUserInfo = z.object({
-  title_l10n_id: z.string(),
   description_l10n_id: z.string(),
+  title_l10n_id: z.string(),
 });
 
 export const AllowedState = z
   .object({
-    title_l10n_id: z.string(),
     description_l10n_id: z.string(),
+    title_l10n_id: z.string(),
   })
   .catchall(z.string());
 
 export type AllowedState = z.infer<typeof AllowedState>;
 
 const CredentialPurpose = z.object({
-  id: z.string(),
-  description: z.string().optional(),
-  claims_required: z.array(z.string()).optional(),
   claim_recommended: z.array(z.string()).optional(),
+  claims_required: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  id: z.string(),
 });
 
 const CredentialIssuer = z.object({
-  id: z.string(),
-  organization_name: z.string().optional(),
-  organization_name_l10n_id: z.string().optional(),
-  organization_code: z.string(),
-  organization_country: z.string(),
-  legal_type: z.string().optional(),
   contacts: z.array(z.string()).optional(),
   homepage_uri: z.string().optional(),
+  id: z.string(),
+  issuance_flows: z.object({ deferred_flow: z.boolean() }).optional(),
+  legal_type: z.string().optional(),
   logo_uri: z.string().optional(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  organization_name: z.string().optional(),
+  organization_name_l10n_id: z.string().optional(),
   policy_uri: z.string().optional(),
-  tos_uri: z.string().optional(),
   service_documentation: z.string().optional(),
-  issuance_flows: z.object({ deferred_flow: z.boolean() }).optional(),
+  tos_uri: z.string().optional(),
 });
 
 const AuthenticSource = z.object({
+  contacts: z.array(z.string()).optional(),
+  data_origin_l10n_id: z.string().optional(),
+  homepage_uri: z.string().optional(),
   id: z.string(),
-  organization_name: z.string().optional(),
-  organization_name_l10n_id: z.string().optional(),
+  logo_uri: z.string().optional(),
   organization_code: z.string().optional(),
   organization_country: z.string(),
+  organization_name: z.string().optional(),
+  organization_name_l10n_id: z.string().optional(),
   organization_type: z.string(),
-  contacts: z.array(z.string()).optional(),
-  homepage_uri: z.string().optional(),
-  logo_uri: z.string().optional(),
   user_information: z.string().optional(),
   user_information_l10n_id: z.string().optional(),
 });
@@ -69,18 +71,18 @@ export type AuthenticSource = z.infer<typeof AuthenticSource>;
 
 export const CredentialFormat = z.object({
   configuration_id: z.string(),
-  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
-  vct: z.string().url().optional(),
   docType: z.string().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
   schema_uri: z.string().url().optional(),
   "schema_uri#integrity": z.string().optional(),
+  vct: z.string().url().optional(),
 });
 export type CredentialFormat = z.infer<typeof CredentialFormat>;
 
 export const Claim = z.object({
+  display_name: z.string(),
   name: z.string(),
   taxonomy_ref: z.string(),
-  display_name: z.string(),
 });
 
 /**
@@ -88,37 +90,36 @@ export const Claim = z.object({
  * Please note that some of the version-specific properties might be missing in this representation.
  */
 export const DigitalCredential = z.object({
-  version: z.string(),
+  administrative_expiration_user_info:
+    AdministrativeExpirationUserInfo.optional(),
+  authentic_sources: z.array(AuthenticSource),
+  classes: z.array(z.string()).optional(),
   credential_type: z.string(),
+  description: z.string().optional(),
+  domains: z.array(z.string()).optional(),
+  formats: z.array(CredentialFormat).optional(),
+  issuers: z.array(CredentialIssuer),
   legal_type: z.string(),
   name: z.string().optional(),
   name_l10n_id: z.string().optional(),
-  description: z.string().optional(),
+  parent_credentials: z.array(z.string()).optional(),
+  purposes: z.array(z.union([z.string(), CredentialPurpose])),
   restriction_policy: z
     .object({
       presentation_flows: z.object({
-        remote: z.boolean(),
         proximity: z.boolean(),
+        remote: z.boolean(),
       }),
     })
     .optional(),
   validity_info: z.object({
-    max_validity_days: z.number(),
-    status_methods: z.array(z.string()),
     administrative_expiration_user_info:
       AdministrativeExpirationUserInfo.optional(),
     allowed_states: z.array(z.union([z.string(), AllowedState])),
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
   }),
-  administrative_expiration_user_info:
-    AdministrativeExpirationUserInfo.optional(),
-  domains: z.array(z.string()).optional(),
-  classes: z.array(z.string()).optional(),
-  purposes: z.array(z.union([z.string(), CredentialPurpose])),
-  issuers: z.array(CredentialIssuer),
-  authentic_sources: z.array(AuthenticSource),
-  parent_credentials: z.array(z.string()).optional(),
-  formats: z.array(CredentialFormat).optional(),
-  // claims: z.array(Claim), // TODO: [SIW-3978] Should we keep claims?
+  version: z.string(),
 });
 export type DigitalCredential = z.infer<typeof DigitalCredential>;
 
@@ -136,31 +137,31 @@ const TaxonomyClass = z.object({
 export type TaxonomyClass = z.infer<typeof TaxonomyClass>;
 
 const TaxonomyDomain = z.object({
+  classes: z.array(TaxonomyClass),
+  description_l10n_id: z.string(),
   id: z.string(),
   name_l10n_id: z.string(),
-  description_l10n_id: z.string(),
-  classes: z.array(TaxonomyClass),
 });
 export type TaxonomyDomain = z.infer<typeof TaxonomyDomain>;
 
 export const Taxonomy = z.object({
-  id: z.string(),
-  name_l10n_id: z.string(),
   description_l10n_id: z.string(),
   domains: z.array(TaxonomyDomain),
-  purposes: z.array(TaxonomyPurpose),
+  id: z.string(),
   localization: LocalizationInfo.optional(),
+  name_l10n_id: z.string(),
+  purposes: z.array(TaxonomyPurpose),
 });
 export type Taxonomy = z.infer<typeof Taxonomy>;
 
 export const DigitalCredentialsCatalogue = z.object({
-  taxonomy_uri: z.string().url(),
-  taxonomy: Taxonomy.optional(),
+  as_localization: LocalizationInfo.optional(),
   credentials: z.array(DigitalCredential),
-  iat: UnixTime,
   exp: UnixTime,
+  iat: UnixTime,
   localization: LocalizationInfo.optional(),
-  as_localization: LocalizationInfo.optional(),
+  taxonomy: Taxonomy.optional(),
+  taxonomy_uri: z.string().url(),
 });
 export type DigitalCredentialsCatalogue = z.infer<
   typeof DigitalCredentialsCatalogue

package/src/credentials-catalogue/api/index.ts

@@ -6,14 +6,6 @@ import {
   type Taxonomy,
 } from "./DigitalCredentialsCatalogue";
 
-type FetchContext = { appFetch?: GlobalFetch["fetch"] };
-
-type FetchTranslationsLocalizations = {
-  catalogue?: LocalizationInfo;
-  authenticSources?: LocalizationInfo;
-  taxonomy?: LocalizationInfo;
-};
-
 export interface CredentialsCatalogueApi {
   /**
    * Fetch and parse the Digital Credential Catalogue from the Trust Anchor.
@@ -26,7 +18,7 @@ export interface CredentialsCatalogueApi {
    */
   fetchAndParseCatalogue(
     trustAnchorBaseUrl: string,
-    ctx?: FetchContext
+    ctx?: FetchContext,
   ): Promise<DigitalCredentialsCatalogue>;
 
   /**
@@ -47,7 +39,7 @@ export interface CredentialsCatalogueApi {
   fetchTranslations?(
     localizations: FetchTranslationsLocalizations,
     locales: string[],
-    ctx?: FetchContext
+    ctx?: FetchContext,
   ): Promise<CatalogueTranslations>;
 
   /**
@@ -60,8 +52,18 @@ export interface CredentialsCatalogueApi {
    */
   getStatusL10nIds(
     statusBit: string,
-    credentialConfig: DigitalCredential
-  ): { titleL10nId: string; descriptionL10nId: string } | undefined;
+    credentialConfig: DigitalCredential,
+  ): undefined | { descriptionL10nId: string; titleL10nId: string };
+}
+
+interface FetchContext {
+  appFetch?: GlobalFetch["fetch"];
+}
+
+interface FetchTranslationsLocalizations {
+  authenticSources?: LocalizationInfo;
+  catalogue?: LocalizationInfo;
+  taxonomy?: LocalizationInfo;
 }
 
 export {

package/src/credentials-catalogue/common/get-status-l10n-ids.ts

@@ -1,5 +1,5 @@
-import { AllowedState } from "../api/DigitalCredentialsCatalogue";
 import { type CredentialsCatalogueApi } from "../api";
+import { AllowedState } from "../api/DigitalCredentialsCatalogue";
 
 /**
  * Given a statusBit (e.g. "0x00", "0x0B") and a DigitalCredential from the
@@ -9,17 +9,17 @@ import { type CredentialsCatalogueApi } from "../api";
  */
 export const getStatusL10nIds: CredentialsCatalogueApi["getStatusL10nIds"] = (
   statusBit,
-  credentialConfig
+  credentialConfig,
 ) => {
   const normalizedBit = statusBit.toLowerCase();
   const match = credentialConfig.validity_info.allowed_states.find(
     (s): s is AllowedState =>
       typeof s === "object" &&
-      Object.keys(s).some((k) => k.toLowerCase() === normalizedBit)
+      Object.keys(s).some((k) => k.toLowerCase() === normalizedBit),
   );
   if (!match) return undefined;
   return {
-    titleL10nId: match.title_l10n_id,
     descriptionL10nId: match.description_l10n_id,
+    titleL10nId: match.title_l10n_id,
   };
 };

package/src/credentials-catalogue/v1.0.0/fetch-and-parse-catalogue.ts

@@ -1,20 +1,21 @@
 import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
-import { hasStatusOrThrow } from "../../utils/misc";
-import { IoWalletError } from "../../utils/errors";
+
 import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities";
+import { IoWalletError } from "../../utils/errors";
+import { hasStatusOrThrow } from "../../utils/misc";
 import { type CredentialsCatalogueApi as Api } from "../api";
 import { mapToCredentialsCatalogue } from "./mappers";
 
 export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
   trustAnchorBaseUrl,
-  { appFetch = fetch } = {}
+  { appFetch = fetch } = {},
 ) => {
   const trustAnchorConfig =
     await getTrustAnchorEntityConfiguration(trustAnchorBaseUrl);
 
   const responseText = await appFetch(
     `${trustAnchorConfig.payload.sub}/.well-known/credential-catalogue`,
-    { method: "GET" }
+    { method: "GET" },
   )
     .then(hasStatusOrThrow(200))
     .then((res) => res.text());
@@ -23,12 +24,12 @@ export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
   const catalogueKid = responseJwt.protectedHeader.kid;
 
   const trustAnchorJwk = trustAnchorConfig.payload.jwks.keys.find(
-    (jwk) => jwk.kid === catalogueKid
+    (jwk) => jwk.kid === catalogueKid,
   );
 
   if (!trustAnchorJwk) {
     throw new IoWalletError(
-      `Could not find JWK with kid ${catalogueKid} in Trust Anchor's Entity Configuration`
+      `Could not find JWK with kid ${catalogueKid} in Trust Anchor's Entity Configuration`,
     );
   }
 

package/src/credentials-catalogue/v1.0.0/index.ts

@@ -1,6 +1,7 @@
 import type { CredentialsCatalogueApi } from "../api";
-import { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
+
 import { getStatusL10nIds } from "../common/get-status-l10n-ids";
+import { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
 
 export const CredentialsCatalogue: CredentialsCatalogueApi = {
   fetchAndParseCatalogue,

package/src/credentials-catalogue/v1.0.0/mappers.ts

@@ -13,7 +13,6 @@ export const mapToCredentialsCatalogue = createMapper<
   DigitalCredentialsCatalogueType
 >(
   ({ payload }) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { catalog_version, ...rest } = payload;
     return {
       ...rest,
@@ -23,7 +22,7 @@ export const mapToCredentialsCatalogue = createMapper<
           ({ source_type, ...as }) => ({
             ...as,
             organization_type: source_type,
-          })
+          }),
         ),
       })),
     };
@@ -31,5 +30,5 @@ export const mapToCredentialsCatalogue = createMapper<
   {
     inputSchema: DigitalCredentialsCatalogueJwt,
     outputSchema: DigitalCredentialsCatalogue,
-  }
+  },
 );

package/src/credentials-catalogue/v1.0.0/types.ts

@@ -1,75 +1,76 @@
 import * as z from "zod";
+
 import { UnixTime } from "../../utils/zod";
 
 const CredentialPurpose = z.object({
-  id: z.string(),
-  description: z.string(),
   category: z.string().optional(),
-  subcategory: z.string().optional(),
-  claims_required: z.array(z.string()),
   claim_recommended: z.array(z.string()),
+  claims_required: z.array(z.string()),
+  description: z.string(),
+  id: z.string(),
+  subcategory: z.string().optional(),
 });
 
 const CredentialIssuer = z.object({
-  id: z.string(),
-  organization_name: z.string(),
-  organization_code: z.string(),
-  organization_country: z.string(),
   contacts: z.array(z.string()).optional(),
   homepage_uri: z.string().optional(),
+  id: z.string(),
   logo_uri: z.string().optional(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  organization_name: z.string(),
   policy_uri: z.string().optional(),
   tos_uri: z.string().optional(),
 });
 
 const AuthenticSource = z.object({
+  contacts: z.array(z.string()).optional(),
+  homepage_uri: z.string().optional(),
   id: z.string(),
-  organization_name: z.string(),
+  logo_uri: z.string().optional(),
   organization_code: z.string(),
   organization_country: z.string(),
+  organization_name: z.string(),
   source_type: z.string(),
-  contacts: z.array(z.string()).optional(),
-  homepage_uri: z.string().optional(),
-  logo_uri: z.string().optional(),
   user_information: z.string().optional(),
 });
 
 const CredentialFormat = z.object({
   configuration_id: z.string(),
-  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
-  vct: z.string().url().optional(),
   docType: z.string().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
   schema_uri: z.string().url().optional(),
   "schema_uri#integrity": z.string().optional(),
+  vct: z.string().url().optional(),
 });
 
 const Claim = z.object({
+  display_name: z.string(),
   name: z.string(),
   taxonomy_ref: z.string(),
-  display_name: z.string(),
 });
 
 export const DigitalCredential = z.object({
-  version: z.string(),
+  authentic_sources: z.array(AuthenticSource),
+  authentication: z.object({
+    min_loa: z.string(),
+    supported_eid_schemes: z.array(z.string()),
+    user_auth_required: z.boolean(),
+  }),
+  claims: z.array(Claim),
   credential_type: z.string(),
+  description: z.string(),
+  formats: z.array(CredentialFormat),
+  issuers: z.array(CredentialIssuer),
   legal_type: z.string(),
   name: z.string(),
-  description: z.string(),
+  purposes: z.array(CredentialPurpose),
   validity_info: z.object({
+    allowed_states: z.array(z.string()),
     max_validity_days: z.number(),
     status_methods: z.array(z.string()),
-    allowed_states: z.array(z.string()),
   }),
-  authentication: z.object({
-    user_auth_required: z.boolean(),
-    min_loa: z.string(),
-    supported_eid_schemes: z.array(z.string()),
-  }),
-  purposes: z.array(CredentialPurpose),
-  issuers: z.array(CredentialIssuer),
-  authentic_sources: z.array(AuthenticSource),
-  formats: z.array(CredentialFormat),
-  claims: z.array(Claim),
+  version: z.string(),
 });
 
 /**
@@ -80,16 +81,16 @@ export const DigitalCredential = z.object({
  */
 export const DigitalCredentialsCatalogueJwt = z.object({
   header: z.object({
-    typ: z.string(),
     alg: z.string(),
     kid: z.string(),
+    typ: z.string(),
   }),
   payload: z.object({
     catalog_version: z.string(),
-    taxonomy_uri: z.string().url(),
     credentials: z.array(DigitalCredential),
-    iat: UnixTime,
     exp: UnixTime,
+    iat: UnixTime,
+    taxonomy_uri: z.string().url(),
   }),
 });
 export type DigitalCredentialsCatalogueJwt = z.infer<