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

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

@@ -1,10 +1,10 @@
-import { assert } from "../../utils/misc";
-import { keyBy, groupBy } from "../../utils/object";
 import { createMapper } from "../../utils/mappers";
+import { assert } from "../../utils/misc";
+import { groupBy, keyBy } from "../../utils/object";
 import {
-  DigitalCredentialsCatalogue,
-  type CredentialFormat as ApiCredentialFormat,
   type AuthenticSource as ApiAuthenticSource,
+  type CredentialFormat as ApiCredentialFormat,
+  DigitalCredentialsCatalogue,
 } from "../api/DigitalCredentialsCatalogue";
 import {
   AuthenticSourceRegistry,
@@ -33,31 +33,32 @@ export const mapToCredentialsCatalogue = createMapper<
   ]) => {
     const authSourcesById = keyBy(
       authSourceRegistry.authentic_sources,
-      "entity_id"
+      "entity_id",
     );
     const schemasByCredentialType = groupBy(
       schemaRegistry.schemas,
-      "credential_type"
+      "credential_type",
     );
 
     const resolveAuthSource = ({
-      id,
       dataset_id,
+      id,
     }: {
-      id: string;
       dataset_id: string;
+      id: string;
     }): ApiAuthenticSource => {
       const as = authSourcesById.get(id);
       assert(as, `AS ${id} must be present in the Authentic Source Registry`);
       const { ipa_code, organization_name_l10n_id, ...rest } =
         as.organization_info;
       const dataCapability = as.data_capabilities.find(
-        (dc) => dc.dataset_id === dataset_id
+        (dc) => dc.dataset_id === dataset_id,
       );
       return {
+        data_origin_l10n_id: dataCapability?.data_origin_l10n_id,
         id,
-        organization_name_l10n_id,
         organization_code: ipa_code,
+        organization_name_l10n_id,
         user_information_l10n_id: dataCapability?.user_information_l10n_id,
         ...rest,
       };
@@ -67,46 +68,46 @@ export const mapToCredentialsCatalogue = createMapper<
       const schemas = schemasByCredentialType.get(credentialType);
       assert(
         schemas,
-        `Schemas for ${credentialType} must be present in the Schema Registry`
+        `Schemas for ${credentialType} must be present in the Schema Registry`,
       );
       return schemas.map((schema) => ({
         // Since the schema registry does not contain the actual configuration ID, it is composed according
         // to the IT-Wallet Credential Issuer's convention. Note that this might not be true for every Issuer.
         configuration_id: `${schema.format.replace(/[+-]/g, "_")}_${schema.credential_type}`,
-        format: schema.format,
-        vct: schema.vct,
         docType: schema.docType,
+        format: schema.format,
         schema_uri: schema.schema_uri,
         "schema_uri#integrity": schema["schema_uri#integrity"],
+        vct: schema.vct,
       }));
     };
 
     return {
       ...catalogueJwt.payload,
-      taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
-      taxonomy: {
-        id: taxonomyRegistry.id,
-        name_l10n_id: taxonomyRegistry.name_l10n_id,
-        description_l10n_id: taxonomyRegistry.description_l10n_id,
-        domains: taxonomyRegistry.domains,
-        purposes: taxonomyRegistry.purposes,
-        localization: taxonomyRegistry.localization,
-      },
-      localization: catalogueJwt.payload.localization,
       as_localization: authSourceRegistry.localization,
       credentials: catalogueJwt.payload.credentials.map(
         ({ authentic_sources, credential_name_l10n_id, ...credential }) => ({
-          name_l10n_id: credential_name_l10n_id,
-          formats: resolveFormats(credential.credential_type),
           authentic_sources: authentic_sources
             ? authentic_sources.map(resolveAuthSource)
             : [],
+          formats: resolveFormats(credential.credential_type),
+          name_l10n_id: credential_name_l10n_id,
           ...credential,
-        })
+        }),
       ),
+      localization: catalogueJwt.payload.localization,
+      taxonomy: {
+        description_l10n_id: taxonomyRegistry.description_l10n_id,
+        domains: taxonomyRegistry.domains,
+        id: taxonomyRegistry.id,
+        localization: taxonomyRegistry.localization,
+        name_l10n_id: taxonomyRegistry.name_l10n_id,
+        purposes: taxonomyRegistry.purposes,
+      },
+      taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
     };
   },
   {
     outputSchema: DigitalCredentialsCatalogue,
-  }
+  },
 );

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

@@ -1,169 +1,170 @@
 import * as z from "zod";
+
 import { UnixTime } from "../../utils/zod";
 
 const ASDataCapability = z.object({
-  // required per spec
-  dataset_id: z.string(),
-  intended_purposes: z.array(z.string()),
+  // optional per spec (api_specification required in spec but absent in actual responses)
+  api_specification: z.string().optional(),
   available_claims: z.array(
     z.object({
       claim_name: z.string(),
-      order: z.number(),
       mandatory: z.boolean(),
-    })
+      order: z.number(),
+    }),
   ),
-  domains: z.array(z.string()).optional(),
-  data_origin_l10n_id: z.string(),
-  integration_endpoint: z.string().optional(),
-  integration_method: z.string(),
-  user_information_l10n_id: z.string().optional(),
-  // optional per spec (api_specification required in spec but absent in actual responses)
-  api_specification: z.string().optional(),
   background_color: z.string().optional(),
   contacts: z.array(z.string()).optional(),
+  data_origin_l10n_id: z.string(),
   data_provision: z
     .object({
       deferred_flow: z.boolean(),
       immediate_flow: z.boolean(),
     })
     .optional(),
+  // required per spec
+  dataset_id: z.string(),
+  domains: z.array(z.string()).optional(),
+  integration_endpoint: z.string().optional(),
+  integration_method: z.string(),
+  intended_purposes: z.array(z.string()),
   logo_uri: z.string().optional(),
   "logo_uri#integrity": z.string().optional(),
   service_documentation: z.string().optional(),
   update_frequency: z.string().optional(),
+  user_information_l10n_id: z.string().optional(),
 });
 
 export const AuthenticSource = z.object({
+  data_capabilities: z.array(ASDataCapability),
   entity_id: z.string(),
   organization_info: z.object({
-    // required per spec
-    organization_name_l10n_id: z.string(),
-    organization_type: z.string(),
-    organization_country: z.string(),
-    legal_identifier: z.string(),
-    homepage_uri: z.string(),
     contacts: z.array(z.string()),
-    policy_uri: z.string(),
+    dpa_contact: z.string().optional(),
+    homepage_uri: z.string(),
     // conditional: required for public AS
     ipa_code: z.string().optional(),
-    // conditional: required for private AS
-    tos_uri: z.string().optional(),
+    legal_identifier: z.string(),
+    logo_extended_uri: z.string().optional(),
+    "logo_extended_uri#integrity": z.string().optional(),
     // optional per spec
     logo_uri: z.string().optional(),
     "logo_uri#integrity": z.string().optional(),
-    logo_extended_uri: z.string().optional(),
-    "logo_extended_uri#integrity": z.string().optional(),
-    dpa_contact: z.string().optional(),
+    organization_country: z.string(),
+    // required per spec
+    organization_name_l10n_id: z.string(),
+    organization_type: z.string(),
+    policy_uri: z.string(),
+    // conditional: required for private AS
+    tos_uri: z.string().optional(),
   }),
-  data_capabilities: z.array(ASDataCapability),
 });
 export type AuthenticSource = z.infer<typeof AuthenticSource>;
 
 export const Schema = z.object({
-  id: z.string(),
-  version: z.string(),
   credential_type: z.string(),
-  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  description: z.string().optional(),
   docType: z.string().optional(),
-  vct: z.string().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  id: z.string(),
   schema_uri: z.string(),
   "schema_uri#integrity": z.string(),
-  description: z.string().optional(),
+  vct: z.string().optional(),
+  version: z.string(),
 });
 export type Schema = z.infer<typeof Schema>;
 
 const AdministrativeExpirationUserInfo = z.object({
-  title_l10n_id: z.string(),
   description_l10n_id: z.string(),
+  title_l10n_id: z.string(),
 });
 
 const AllowedState = z
   .object({
-    title_l10n_id: z.string(),
     description_l10n_id: z.string(),
+    title_l10n_id: z.string(),
   })
   .catchall(z.string());
 
 const CredentialIssuer = z.object({
-  id: z.string(),
-  organization_name_l10n_id: z.string(),
-  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_l10n_id: z.string(),
   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(),
 });
 
 export const DigitalCredential = z.object({
-  version: z.string(),
-  credential_type: z.string(),
+  administrative_expiration_user_info:
+    AdministrativeExpirationUserInfo.optional(),
+  authentic_sources: z
+    .array(z.object({ dataset_id: z.string(), id: z.string() }))
+    .optional(),
+  authentication: z.object({
+    min_loa: z.string(),
+    supported_schemes: z.array(z.string()),
+    user_auth_required: z.boolean(),
+  }),
+  classes: z.array(z.string()).optional(),
   credential_name_l10n_id: z.string(),
+  credential_type: z.string(),
+  domains: z.array(z.string()).optional(),
+  issuers: z.array(CredentialIssuer),
   legal_type: z.string(),
+  parent_credentials: z.array(z.string()).optional(),
+  purposes: z.array(z.string()),
   restriction_policy: z
     .object({
-      allowed_wallet_ids: z.array(z.string()).optional(),
       allowed_issuer_ids: z.array(z.string()).optional(),
+      allowed_wallet_ids: z.array(z.string()).optional(),
       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(AllowedState),
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
   }),
-  administrative_expiration_user_info:
-    AdministrativeExpirationUserInfo.optional(),
-  authentication: z.object({
-    user_auth_required: z.boolean(),
-    min_loa: z.string(),
-    supported_schemes: z.array(z.string()),
-  }),
-  domains: z.array(z.string()).optional(),
-  classes: z.array(z.string()).optional(),
-  purposes: z.array(z.string()),
-  issuers: z.array(CredentialIssuer),
-  authentic_sources: z
-    .array(z.object({ id: z.string(), dataset_id: z.string() }))
-    .optional(),
-  parent_credentials: z.array(z.string()).optional(),
+  version: z.string(),
 });
 
 const JwtHeader = z.object({
-  typ: z.string(),
   alg: z.string(),
   kid: z.string(),
+  typ: z.string(),
   x5c: z.array(z.string()).optional(),
 });
 
 /**
  * Schema registry, available at a dedicated endpoint.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#schema-registry
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html#schema-registry
  */
 export const SchemaRegistry = z.object({
-  version: z.string(),
   last_modified: z.string().optional(),
   last_updated: z.string().optional(),
   schemas: z.array(Schema),
+  version: z.string(),
 });
 export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
 
 /**
  * Authentic Source registry, available at a dedicated endpoint.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#authentic-source-registry
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html#authentic-source-registry
  */
 export const AuthenticSourceRegistry = z.object({
+  authentic_sources: z.array(AuthenticSource),
   id: z.string().optional(),
-  version: z.string(),
   last_modified: z.string(),
   localization: z
     .object({
@@ -173,20 +174,22 @@ export const AuthenticSourceRegistry = z.object({
       version: z.string(),
     })
     .optional(),
-  authentic_sources: z.array(AuthenticSource),
+  version: z.string(),
 });
 export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
 
 /**
  * The Digital Credentials Catalogue published by the Trust Anchor.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#digital-credentials-catalog
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html#digital-credentials-catalog
  */
 export const DigitalCredentialsCatalogueJwt = z.object({
   header: JwtHeader,
   payload: z.object({
-    iss: z.string(),
+    credentials: z.array(DigitalCredential),
+    exp: UnixTime,
+    iat: UnixTime,
     id: z.string(),
-    version: z.string(),
+    iss: z.string(),
     last_modified: z.string(),
     localization: z
       .object({
@@ -196,9 +199,7 @@ export const DigitalCredentialsCatalogueJwt = z.object({
         version: z.string(),
       })
       .optional(),
-    credentials: z.array(DigitalCredential),
-    iat: UnixTime,
-    exp: UnixTime,
+    version: z.string(),
   }),
 });
 export type DigitalCredentialsCatalogueJwt = z.infer<
@@ -208,26 +209,26 @@ export type DigitalCredentialsCatalogueJwt = z.infer<
 /**
  * Registry discovery info, used to discover all the Registry Infrastructure endpoints.
  * This is the entrypoint to build the full catalogue.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#registry-discovery-endpoint
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html#registry-discovery-endpoint
  */
 const RegistryDiscoveryEndpoints = z.object({
-  claims_registry: z.string(),
   authentic_sources: z.string(),
+  claims_registry: z.string(),
   credential_catalog: z.string(),
-  taxonomy: z.string(),
-  schema_registry: z.string(),
-  federation_list_endpoint: z.string(),
   federation_fetch_endpoint: z.string(),
+  federation_list_endpoint: z.string(),
   federation_resolve_endpoint: z.string(),
   federation_trust_mark_status_endpoint: z.string(),
+  schema_registry: z.string(),
+  taxonomy: z.string(),
 });
 
 export const RegistryDiscoveryJwt = z.object({
   header: JwtHeader,
   payload: z.object({
-    registry_version: z.string(),
-    last_updated: z.string(),
     endpoints: RegistryDiscoveryEndpoints,
+    last_updated: z.string(),
+    registry_version: z.string(),
   }),
 });
 export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;
@@ -253,21 +254,22 @@ const TaxonomyClass = z.object({
  * Taxonomy domain containing classes.
  */
 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),
 });
 
 /**
  * Taxonomy registry, available at a dedicated endpoint.
  * Provides a hierarchical classification of domains, classes, and purposes.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#taxonomy
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html#taxonomy
  */
 export const TaxonomyRegistry = z.object({
-  version: z.string(),
-  last_modified: z.string(),
+  description_l10n_id: z.string(),
+  domains: z.array(TaxonomyDomain),
   id: z.string(),
+  last_modified: z.string(),
   localization: z
     .object({
       available_locales: z.array(z.string()),
@@ -277,8 +279,7 @@ export const TaxonomyRegistry = z.object({
     })
     .optional(),
   name_l10n_id: z.string(),
-  description_l10n_id: z.string(),
-  domains: z.array(TaxonomyDomain),
   purposes: z.array(TaxonomyPurpose),
+  version: z.string(),
 });
 export type TaxonomyRegistry = z.infer<typeof TaxonomyRegistry>;

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

@@ -1,18 +1,20 @@
-import * as z from "zod";
 import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
-import { assert, hasStatusOrThrow } from "../../utils/misc";
-import { IoWalletError } from "../../utils/errors";
+import * as z from "zod";
+
 import type { JWK } from "../../utils/jwk";
 
+import { IoWalletError } from "../../utils/errors";
+import { assert, hasStatusOrThrow } from "../../utils/misc";
+
 type FetchRegistryParams<T> = {
-  schema: z.ZodType<T>;
   appFetch?: GlobalFetch["fetch"];
+  schema: z.ZodType<T>;
 } & ({ asJson: true } | { asJson?: false; jwks: JWK[] });
 
 /**
  * Utility to fetch an entity from the Registry Infrastructure.
  * The function supports `application/json` and signed JOSE/JWT responses.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html
  *
  * @param url The url to fetch from
  * @param params.schema The Zod schema to validate the response
@@ -23,15 +25,15 @@ type FetchRegistryParams<T> = {
  */
 export const fetchRegistry = async <T>(
   url: string,
-  params: FetchRegistryParams<T>
+  params: FetchRegistryParams<T>,
 ): Promise<T> => {
-  const { schema, appFetch = fetch, asJson = false } = params;
+  const { appFetch = fetch, asJson = false, schema } = params;
 
   const response = await appFetch(url, {
-    method: "GET",
     headers: {
       Accept: asJson ? "application/json" : "application/jose, application/jwt",
     },
+    method: "GET",
   }).then(hasStatusOrThrow(200));
 
   const contentType = response.headers.get("Content-Type");
@@ -53,7 +55,7 @@ export const fetchRegistry = async <T>(
     const signatureJwk = params.jwks.find((jwk) => jwk.kid === headerKid);
     if (!signatureJwk) {
       throw new IoWalletError(
-        `Could not find JWK with kid ${headerKid} in Trust Anchor's Entity Configuration`
+        `Could not find JWK with kid ${headerKid} in Trust Anchor's Entity Configuration`,
       );
     }
     await verify(responseText, signatureJwk);
@@ -64,14 +66,14 @@ export const fetchRegistry = async <T>(
   }
 
   throw new IoWalletError(
-    `Unsupported content-type for ${url}: ${contentType}`
+    `Unsupported content-type for ${url}: ${contentType}`,
   );
 };
 
 /**
  * Fetch a locale bundle file from the Registry Infrastructure.
  * Bundle files are flat JSON objects mapping l10n_id keys to translated strings.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/registry.html
  *
  * @param baseUri The base URI from a registry's localization object
  * @param locale The locale code (e.g. "it", "en")
@@ -81,19 +83,19 @@ export const fetchRegistry = async <T>(
 export const fetchLocaleBundle = async (
   baseUri: string,
   locale: string,
-  appFetch: GlobalFetch["fetch"] = fetch
+  appFetch: GlobalFetch["fetch"] = fetch,
 ): Promise<Record<string, string>> => {
   const url = `${baseUri.replace(/\/$/, "")}/${locale}.json`;
 
   const response = await appFetch(url, {
-    method: "GET",
     headers: { Accept: "application/json" },
+    method: "GET",
   }).then(hasStatusOrThrow(200));
 
   const contentType = response.headers.get("Content-Type");
   if (!contentType?.includes("application/json")) {
     throw new IoWalletError(
-      `Locale bundle at ${url} returned unexpected Content-Type: ${contentType}`
+      `Locale bundle at ${url} returned unexpected Content-Type: ${contentType}`,
     );
   }
 

package/src/index.ts

@@ -1,54 +1,56 @@
 import type { AuthorizationContext } from "./utils/auth";
-import { fixBase64EncodingOnKey } from "./utils/jwk";
+import type { IntegrityContext } from "./utils/integrity";
 // polyfill due to known bugs on URL implementation for react native
 // https://github.com/facebook/react-native/issues/24428
 import "react-native-url-polyfill/auto";
 
-import * as Trust from "./trust";
-import * as CredentialsCatalogue from "./credentials-catalogue";
 import * as CredentialIssuance from "./credential/issuance";
 import * as CredentialOffer from "./credential/offer";
-import * as CredentialStatus from "./credential/status";
 import * as RemotePresentation from "./credential/presentation";
+import * as CredentialStatus from "./credential/status";
 import * as Trustmark from "./credential/trustmark";
-import * as SdJwt from "./sd-jwt";
+import * as CredentialsCatalogue from "./credentials-catalogue";
+import * as KeyAttestation from "./key-attestation";
 import * as Mdoc from "./mdoc";
-import * as Errors from "./utils/errors";
-import * as WalletInstanceAttestation from "./wallet-instance-attestation";
-import * as WalletUnitAttestation from "./wallet-unit-attestation";
-import * as WalletInstance from "./wallet-instance";
-import * as Logging from "./utils/logging";
-import { AuthorizationDetail, AuthorizationDetails } from "./utils/par";
+import * as SdJwt from "./sd-jwt";
+import * as Trust from "./trust";
 import {
   createCryptoContextFor,
+  getJwkFromCertificateChain,
   type KeyAttestationCryptoContext,
 } from "./utils/crypto";
-import type { IntegrityContext } from "./utils/integrity";
+import * as Errors from "./utils/errors";
+import { fixBase64EncodingOnKey } from "./utils/jwk";
+import * as Logging from "./utils/logging";
+import { AuthorizationDetail, AuthorizationDetails } from "./utils/par";
+import * as WalletInstance from "./wallet-instance";
+import * as WalletInstanceAttestation from "./wallet-instance-attestation";
 
 export {
-  Trust,
+  AuthorizationDetail,
+  AuthorizationDetails,
+  createCryptoContextFor,
   CredentialIssuance,
   CredentialOffer,
   CredentialsCatalogue,
   CredentialStatus,
-  RemotePresentation,
-  SdJwt,
-  Mdoc,
-  WalletInstanceAttestation,
-  WalletUnitAttestation,
-  WalletInstance,
-  Trustmark,
   Errors,
-  createCryptoContextFor,
-  AuthorizationDetail,
-  AuthorizationDetails,
   fixBase64EncodingOnKey,
+  getJwkFromCertificateChain,
+  KeyAttestation,
   Logging,
+  Mdoc,
+  RemotePresentation,
+  SdJwt,
+  Trust,
+  Trustmark,
+  WalletInstance,
+  WalletInstanceAttestation,
 };
 
 export type {
-  IntegrityContext,
   AuthorizationContext,
+  IntegrityContext,
   KeyAttestationCryptoContext,
 };
 

package/{lib/module/wallet-unit-attestation → src/key-attestation}/README.md

@@ -1,15 +1,15 @@
-# Wallet Unit Attestation
+# Key Attestation
 
-This flow is used to obtain a [**Wallet Unit Attestation**](https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/wallet-solution-requirements.html#wallet-unit-attestation-requirements). The WUA is bound to one or more cryptographic keys, that must be provided by the consumer application:
-- `keyAttestationCryptoContext` one or more objects that extend the `CryptoContext` with a function to generate a WSCD-stored key with an optional key attestation (Android only); these are the keys that will be attested in the WUA.
+This flow is used to obtain a [**Key Attestation**](https://italia.github.io/eid-wallet-it-docs/releases/1.4.6/en/wallet-solution-requirements.html#key-attestation-requirements) (KA). The Key Attestation is bound to one or more cryptographic keys, that must be provided by the consumer application:
+- `keyAttestationCryptoContext` one or more objects that extend the `CryptoContext` with a function to generate a WSCD-stored key with an optional [Android key attestation](https://developer.android.com/privacy-and-security/security-key-attestation); these are the keys that will be attested in the KA.
 - `integrityContext` object that is used to verify the integrity of the device where the app is running. The key tag must be the same used when creating the Wallet Instance.
 
 #### Note
-Before invoking `WalletUnitAttestation`'s functions, it is necessary to check whether the feature is supported by the current IoWallet instance.
+Before invoking `KeyAttestation`'s functions, it is necessary to check whether the feature is supported by the current IoWallet instance.
 ```ts
-const wallet = new IoWallet({ version: "1.3.3" });
+const wallet = new IoWallet({ version: "1.4.6" });
 
-if (wallet.WalletUnitAttestation.isSupported) {
+if (wallet.KeyAttestation.isSupported) {
   // Get the WUA
 }
 ```
@@ -46,11 +46,11 @@ const keysToAttest: KeyAttestationCryptoContext[] = [
 ];
 
 /**
- * Obtain a new Wallet Unit Attestation.
+ * Obtain a new Key Attestation.
  * WARNING: The integrity context must be the same used when creating the Wallet Instance with the same keytag.
  */
-const wallet = new IoWallet({ version: "1.3.3" });
-const issuedAttestation = await wallet.WalletUnitAttestation.getAttestation(
+const wallet = new IoWallet({ version: "1.4.6" });
+const issuedAttestation = await wallet.KeyAttestation.getAttestation(
   {
     walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
     walletSolutionId: "exampleId",