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

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(),
-  schema_uri: z.string().url().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  schema_uri: z.url().optional(),
   "schema_uri#integrity": z.string().optional(),
+  vct: z.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,36 +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(),
+  version: z.string(),
 });
 export type DigitalCredential = z.infer<typeof DigitalCredential>;
 
@@ -135,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.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/index.ts

@@ -1,3 +1,3 @@
 export type * from "./api";
 export { CredentialsCatalogue as V1_0_0 } from "./v1.0.0";
-export { CredentialsCatalogue as V1_3_3 } from "./v1.3.3";
+export { CredentialsCatalogue as V1_4_6 } from "./v1.4.6";

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(),
-  schema_uri: z.string().url().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  schema_uri: z.url().optional(),
   "schema_uri#integrity": z.string().optional(),
+  vct: z.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.url(),
   }),
 });
 export type DigitalCredentialsCatalogueJwt = z.infer<

package/src/credentials-catalogue/{v1.3.3 → v1.4.6}/fetch-and-parse-catalogue.ts

@@ -1,5 +1,6 @@
-import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities"; // TODO: use trust from v1.3.3
+import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities"; // TODO: use trust from v1.4.6
 import { type CredentialsCatalogueApi as Api } from "../api";
+import { mapToCredentialsCatalogue } from "./mappers";
 import {
   AuthenticSourceRegistry,
   DigitalCredentialsCatalogueJwt,
@@ -7,50 +8,49 @@ import {
   SchemaRegistry,
   TaxonomyRegistry,
 } from "./types";
-import { mapToCredentialsCatalogue } from "./mappers";
 import { fetchRegistry } from "./utils";
 
 export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
   trustAnchorBaseUrl,
-  { appFetch = fetch } = {}
+  { appFetch = fetch } = {},
 ) => {
   const trustAnchorConfig = await getTrustAnchorEntityConfiguration(
     trustAnchorBaseUrl,
-    { appFetch }
+    { appFetch },
   );
   const trustAnchorJwks = trustAnchorConfig.payload.jwks.keys;
 
   const discovery = await fetchRegistry(
     `${trustAnchorConfig.payload.sub}/.well-known/it-wallet-registry`,
     {
-      schema: RegistryDiscoveryJwt,
-      jwks: trustAnchorJwks,
       appFetch,
-    }
+      jwks: trustAnchorJwks,
+      schema: RegistryDiscoveryJwt,
+    },
   );
   const { endpoints } = discovery.payload;
 
   // Fetch registries necessary to build the full catalogue
   const registries = await Promise.all([
     fetchRegistry(endpoints.credential_catalog, {
-      schema: DigitalCredentialsCatalogueJwt,
-      jwks: trustAnchorJwks,
       appFetch,
+      jwks: trustAnchorJwks,
+      schema: DigitalCredentialsCatalogueJwt,
     }),
     fetchRegistry(endpoints.authentic_sources, {
-      schema: AuthenticSourceRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: AuthenticSourceRegistry,
     }),
     fetchRegistry(endpoints.schema_registry, {
-      schema: SchemaRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: SchemaRegistry,
     }),
     fetchRegistry(endpoints.taxonomy, {
-      schema: TaxonomyRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: TaxonomyRegistry,
     }),
   ]);
 

package/src/credentials-catalogue/{v1.3.3 → v1.4.6}/fetch-translations.ts

@@ -1,10 +1,11 @@
 import type { CredentialsCatalogueApi as Api } from "../api";
+
 import { fetchLocaleBundle } from "./utils";
 
 export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
-  { catalogue, authenticSources, taxonomy },
+  { authenticSources, catalogue, taxonomy },
   locales,
-  { appFetch = fetch } = {}
+  { appFetch = fetch } = {},
 ) => {
   const result: Record<string, Record<string, string>> = {};
 
@@ -28,7 +29,7 @@ export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
       if (Object.keys(merged).length > 0) {
         result[locale] = merged;
       }
-    })
+    }),
   );
 
   return result;

package/src/credentials-catalogue/{v1.3.3 → v1.4.6}/index.ts

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