@pagopa/io-react-native-wallet 2.5.0 → 3.0.0

package/lib/typescript/wallet-instance-attestation/v1.3.3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/wallet-instance-attestation/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAWzB,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBlC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAChF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/io-react-native-wallet",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Provide data structures, helpers and API for IO Wallet",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -54,7 +54,7 @@
   },
   "devDependencies": {
     "@pagopa/io-react-native-crypto": "^1.2.3",
-    "@pagopa/io-react-native-iso18013": "^0.3.0",
+    "@pagopa/io-react-native-iso18013": "^0.7.0",
     "@pagopa/io-react-native-jwt": "^2.1.0",
     "@react-native/babel-preset": "0.78.3",
     "@react-native/eslint-config": "0.78.3",
@@ -110,12 +110,16 @@
   },
   "jest": {
     "preset": "react-native",
+    "transform": {
+      "\\.[jt]sx?$": "babel-jest",
+      "\\.mjs$": "babel-jest"
+    },
     "modulePathIgnorePatterns": [
       "<rootDir>/example/node_modules",
       "<rootDir>/lib/"
     ],
     "transformIgnorePatterns": [
-      "node_modules/(?!(jest-)?@react-native|react-native|uuid|@pagopa/io-react-native-iso18013)"
+      "node_modules/(?!(jest-)?@react-native|react-native|uuid|@pagopa/io-react-native-iso18013|@openid4vc|dcql)"
     ],
     "setupFiles": [
       "<rootDir>/jestSetup.js"
@@ -136,18 +140,21 @@
     ]
   },
   "dependencies": {
-    "@sd-jwt/core": "^0.18.0",
-    "@sd-jwt/crypto-nodejs": "^0.18.0",
-    "@sd-jwt/types": "^0.18.0",
-    "dcql": "^0.2.21",
-    "js-base64": "^3.7.7",
-    "js-sha256": "^0.9.0",
-    "jsonpath-plus": "^10.2.0",
+    "@pagopa/io-wallet-oauth2": "^1.0.0",
+    "@pagopa/io-wallet-oid4vci": "^1.0.0",
+    "@pagopa/io-wallet-oid4vp": "^1.0.0",
+    "@pagopa/io-wallet-utils": "^1.0.0",
+    "@sd-jwt/core": "^0.19.0",
+    "@sd-jwt/crypto-nodejs": "^0.19.0",
+    "@sd-jwt/jwt-status-list": "^0.19.0",
+    "@sd-jwt/types": "^0.19.0",
+    "dcql": "^3.0.0",
+    "js-base64": "^3.7.8",
+    "js-sha256": "^0.11.1",
     "jsrsasign": "^11.1.0",
-    "parse-url": "^9.2.0",
+    "parse-url": "^10.0.3",
     "react-native-url-polyfill": "^2.0.0",
-    "react-native-uuid": "^2.0.1",
     "uuid": "^11.0.3",
-    "zod": "^3.21.4"
+    "zod": "^3.25.76"
   }
 }

package/src/IoWallet.ts

@@ -0,0 +1,50 @@
+import { ioWalletApiByVersion, type IoWalletApi, type ItwVersion } from "./api";
+
+type DigitalWalletConfig = {
+  /**
+   * IT-Wallet specifications version.
+   */
+  version: ItwVersion;
+};
+
+/**
+ * Instantiate `IoWallet` SDK for a specific IT-Wallet version.
+ *
+ * After initialization, each feature can be accessed under the corresponding namespace.
+ *
+ * @example
+ * const wallet = new IoWallet({ version: "1.0.0" })
+ * wallet.Credential.Issuance.exampleMethod()
+ */
+export class IoWallet {
+  #version: ItwVersion;
+
+  /**
+   * Get the IT-Wallet specifications version bound to this instance.
+   */
+  get version() {
+    return this.#version;
+  }
+
+  constructor({ version }: DigitalWalletConfig) {
+    this.#version = version;
+    const walletApi = ioWalletApiByVersion[version];
+
+    if (!walletApi) {
+      throw new Error(
+        `Invalid version provided: IoWallet does not implement ${version} specifications.`
+      );
+    }
+
+    // Dynamically add features implementations aligned with the specified version
+    for (const feature of Object.keys(walletApi) as (keyof IoWalletApi)[]) {
+      Object.defineProperty(this, feature, {
+        enumerable: true,
+        configurable: false,
+        value: walletApi[feature],
+      });
+    }
+  }
+}
+
+export interface IoWallet extends IoWalletApi {}

package/src/api/index.ts

@@ -0,0 +1,55 @@
+import * as WalletInstance from "../wallet-instance";
+import * as WIA from "../wallet-instance-attestation";
+import * as Trust from "../trust";
+import * as CredentialIssuance from "../credential/issuance";
+import * as CredentialStatus from "../credential/status";
+import * as RemotePresentation from "../credential/presentation";
+import * as CredentialsCatalogue from "../credentials-catalogue";
+import * as Trustmark from "../credential/trustmark";
+import * as CredentialsOffer from "../credential/offer";
+
+export type ItwVersion = "1.0.0" | "1.3.3";
+
+/**
+ * The Wallet public API.
+ */
+export interface IoWalletApi {
+  WalletInstance: WalletInstance.WalletInstanceApi;
+  WalletInstanceAttestation: WIA.WalletInstanceAttestationApi;
+  Trust: Trust.TrustApi;
+  CredentialIssuance: CredentialIssuance.IssuanceApi;
+  CredentialStatus: CredentialStatus.CredentialStatusApi;
+  RemotePresentation: RemotePresentation.RemotePresentationApi;
+  CredentialsCatalogue: CredentialsCatalogue.CredentialsCatalogueApi;
+  Trustmark: Trustmark.TrustmarkApi;
+  CredentialsOffer: CredentialsOffer.OfferApi;
+}
+
+/**
+ * The Wallet API implementations grouped by IT-Wallet specifications version.
+ */
+export const ioWalletApiByVersion: Record<ItwVersion, IoWalletApi> = {
+  "1.0.0": {
+    WalletInstance: WalletInstance.V1_0_0,
+    WalletInstanceAttestation: WIA.V1_0_0,
+    Trust: Trust.V1_0_0,
+    CredentialIssuance: CredentialIssuance.V1_0_0,
+    CredentialStatus: CredentialStatus.V1_0_0,
+    RemotePresentation: RemotePresentation.V1_0_0,
+    CredentialsCatalogue: CredentialsCatalogue.V1_0_0,
+    Trustmark: Trustmark.V1_0_0,
+    CredentialsOffer: CredentialsOffer.V1_0_0,
+  },
+  // TODO: replace v1.0.0 with v1.3.3 implementations
+  "1.3.3": {
+    WalletInstance: WalletInstance.V1_3_3,
+    WalletInstanceAttestation: WIA.V1_3_3,
+    Trust: Trust.V1_0_0,
+    CredentialIssuance: CredentialIssuance.V1_3_3,
+    CredentialStatus: CredentialStatus.V1_3_3,
+    RemotePresentation: RemotePresentation.V1_3_3,
+    CredentialsCatalogue: CredentialsCatalogue.V1_3_3,
+    Trustmark: Trustmark.V1_3_3,
+    CredentialsOffer: CredentialsOffer.V1_3_3,
+  },
+};

package/src/client/generated/wallet-provider.ts

@@ -1,15 +1,30 @@
 import z from "zod";
 
+export type SetWalletInstanceStatusData = z.infer<typeof SetWalletInstanceStatusData>;
+export const SetWalletInstanceStatusData = z.object({
+  status: z.literal("REVOKED"),
+});
+
+export type RevocationReason = z.infer<typeof RevocationReason>;
+export const RevocationReason = z.union([
+  z.literal("CERTIFICATE_REVOKED_BY_ISSUER"),
+  z.literal("NEW_WALLET_INSTANCE_CREATED"),
+  z.literal("WALLET_INSTANCE_RENEWAL"),
+  z.literal("REVOKED_BY_USER"),
+]);
+
+export type WalletInstanceData = z.infer<typeof WalletInstanceData>;
+export const WalletInstanceData = z.object({
+  id: z.string(),
+  is_revoked: z.boolean(),
+  revocation_reason: z.union([RevocationReason, z.undefined()]).optional(),
+});
+
 export type NonceDetailView = z.infer<typeof NonceDetailView>;
 export const NonceDetailView = z.object({
   nonce: z.string(),
 });
 
-export type WalletAttestationView = z.infer<typeof WalletAttestationView>;
-export const WalletAttestationView = z.object({
-  wallet_attestation: z.string(),
-});
-
 export type WalletAttestationsView = z.infer<typeof WalletAttestationsView>;
 export const WalletAttestationsView = z.object({
   wallet_attestations: z.array(
@@ -25,40 +40,16 @@ export const CreateWalletInstanceBody = z.object({
   challenge: z.string(),
   key_attestation: z.string(),
   hardware_key_tag: z.string(),
+  is_renewal: z.union([z.boolean(), z.undefined()]).optional(),
 });
 
 export type CreateWalletAttestationBody = z.infer<typeof CreateWalletAttestationBody>;
 export const CreateWalletAttestationBody = z.object({
-  grant_type: z.literal("urn:ietf:params:oauth:grant-type:jwt-bearer"),
-  assertion: z.string(),
-});
-
-export type CreateWalletAttestationV2Body = z.infer<typeof CreateWalletAttestationV2Body>;
-export const CreateWalletAttestationV2Body = z.object({
   assertion: z.string(),
 });
 
-export type SetWalletInstanceStatusBody = z.infer<typeof SetWalletInstanceStatusBody>;
-export const SetWalletInstanceStatusBody = z.object({
-  status: z.literal("REVOKED"),
-});
-
-export type RevocationReason = z.infer<typeof RevocationReason>;
-export const RevocationReason = z.union([
-  z.literal("CERTIFICATE_REVOKED_BY_ISSUER"),
-  z.literal("NEW_WALLET_INSTANCE_CREATED"),
-  z.literal("REVOKED_BY_USER"),
-]);
-
-export type WalletInstanceData = z.infer<typeof WalletInstanceData>;
-export const WalletInstanceData = z.object({
-  id: z.string(),
-  is_revoked: z.boolean(),
-  revocation_reason: z.union([RevocationReason, z.undefined()]).optional(),
-});
-
-export type ProblemDetail = z.infer<typeof ProblemDetail>;
-export const ProblemDetail = z.object({
+export type ProblemJson = z.infer<typeof ProblemJson>;
+export const ProblemJson = z.object({
   type: z.string().optional(),
   title: z.string().optional(),
   status: z.number().optional(),
@@ -66,6 +57,13 @@ export const ProblemDetail = z.object({
   instance: z.string().optional(),
 });
 
+export type WhitelistedFiscalCodeData = z.infer<typeof WhitelistedFiscalCodeData>;
+export const WhitelistedFiscalCodeData = z.object({
+  whitelisted: z.boolean(),
+  whitelistedAt: z.union([z.string(), z.undefined()]).optional(),
+  fiscalCode: z.string(),
+});
+
 export type get_GetNonce = typeof get_GetNonce;
 export const get_GetNonce = {
   method: z.literal("GET"),
@@ -86,20 +84,10 @@ export const post_CreateWalletInstance = {
 
 export type post_CreateWalletAttestation = typeof post_CreateWalletAttestation;
 export const post_CreateWalletAttestation = {
-  method: z.literal("POST"),
-  path: z.literal("/token"),
-  parameters: z.object({
-    body: CreateWalletAttestationBody,
-  }),
-  response: WalletAttestationView,
-};
-
-export type post_CreateWalletAttestationV2 = typeof post_CreateWalletAttestationV2;
-export const post_CreateWalletAttestationV2 = {
   method: z.literal("POST"),
   path: z.literal("/wallet-attestations"),
   parameters: z.object({
-    body: CreateWalletAttestationV2Body,
+    body: CreateWalletAttestationBody,
   }),
   response: WalletAttestationsView,
 };
@@ -132,22 +120,41 @@ export const put_SetWalletInstanceStatus = {
     path: z.object({
       id: z.string(),
     }),
-    body: SetWalletInstanceStatusBody,
+    body: SetWalletInstanceStatusData,
   }),
   response: z.unknown(),
 };
 
+export type get_HealthCheck = typeof get_HealthCheck;
+export const get_HealthCheck = {
+  method: z.literal("GET"),
+  path: z.literal("/info"),
+  parameters: z.never(),
+  response: z.object({
+    message: z.string().optional(),
+  }),
+};
+
+export type get_IsFiscalCodeWhitelisted = typeof get_IsFiscalCodeWhitelisted;
+export const get_IsFiscalCodeWhitelisted = {
+  method: z.literal("GET"),
+  path: z.literal("/whitelisted-fiscal-code"),
+  parameters: z.never(),
+  response: WhitelistedFiscalCodeData,
+};
+
 // <EndpointByMethod>
 export const EndpointByMethod = {
   get: {
     "/nonce": get_GetNonce,
     "/wallet-instances/current/status": get_GetCurrentWalletInstanceStatus,
     "/wallet-instances/{id}/status": get_GetWalletInstanceStatus,
+    "/info": get_HealthCheck,
+    "/whitelisted-fiscal-code": get_IsFiscalCodeWhitelisted,
   },
   post: {
     "/wallet-instances": post_CreateWalletInstance,
-    "/token": post_CreateWalletAttestation,
-    "/wallet-attestations": post_CreateWalletAttestationV2,
+    "/wallet-attestations": post_CreateWalletAttestation,
   },
   put: {
     "/wallet-instances/{id}/status": put_SetWalletInstanceStatus,

package/src/client/index.ts

@@ -1,7 +1,7 @@
 import { parseRawHttpResponse } from "../utils/misc";
 import { WalletProviderResponseError } from "../utils/errors";
 import {
-  ProblemDetail,
+  ProblemJson,
   createApiClient as createWalletProviderApiClient,
   ApiClient as WalletProviderApiClient,
   type EndpointParameters,
@@ -13,9 +13,9 @@ type RawHttpResponse = Awaited<ReturnType<typeof parseRawHttpResponse>>;
 
 const validateResponse = async (response: Response) => {
   if (!response.ok) {
-    let problemDetail: ProblemDetail = {};
+    let problemDetail: ProblemJson = {};
     try {
-      problemDetail = ProblemDetail.parse(await response.json());
+      problemDetail = ProblemJson.parse(await response.json());
     } catch {
       problemDetail = {
         title: "Invalid response from Wallet Provider",

package/src/credential/index.ts

@@ -1,7 +1,3 @@
-import * as Issuance from "./issuance";
-import * as Presentation from "./presentation";
-import * as Status from "./status";
-import * as Trustmark from "./trustmark";
 import * as Offer from "./offer";
 
-export { Issuance, Presentation, Status, Trustmark, Offer };
+export { Offer };

package/src/credential/issuance/README.md

@@ -98,6 +98,10 @@ The expected result from the authentication process is in `form_post.jwt` format
   <summary>Credential issuance flow</summary>
 
 ```ts
+import { IoWallet } from "@pagopa/io-react-native-wallet";
+
+const wallet = new IoWallet({ version: "1.0.0" });
+
 // Retrieve the integrity key tag from the store and create its context
 const integrityKeyTag = "example"; // Let's assume this is the key tag used to create the wallet instance
 const integrityContext = getIntegrityContext(integrityKeyTag);
@@ -134,22 +138,14 @@ const credentialKeyTag = uuidv4().toString();
 await generate(credentialKeyTag); // Let's assume this function generates a new hardware-backed key pair
 const credentialCryptoContext = createCryptoContextFor(credentialKeyTag);
 
-// Start the issuance flow
-const startFlow: Credential.Issuance.StartFlow = () => ({
-  issuerUrl: WALLET_EAA_PROVIDER_BASE_URL,
-  credentialId: "someCredentialId",
-});
-
-const { issuerUrl, credentialId } = startFlow();
-
 // Evaluate issuer trust
-const { issuerConf } = await Credential.Issuance.evaluateIssuerTrust(issuerUrl);
+const { issuerConf } = await wallet.CredentialIssuance.evaluateIssuerTrust(WALLET_EAA_PROVIDER_BASE_URL);
 
 // Start user authorization
 const { issuerRequestUri, clientId, codeVerifier } =
-  await Credential.Issuance.startUserAuthorization(
+  await wallet.CredentialIssuance.startUserAuthorization(
     issuerConf,
-    [credentialId],
+    ["someCredentialId"],
     { proofType: "none" },
     {
       walletInstanceAttestation,
@@ -160,7 +156,7 @@ const { issuerRequestUri, clientId, codeVerifier } =
   );
 
 const requestObject =
-  await Credential.Issuance.getRequestedCredentialToBePresented(
+  await wallet.CredentialIssuance.getRequestedCredentialToBePresented(
     issuerRequestUri,
     clientId,
     issuerConf,
@@ -169,7 +165,7 @@ const requestObject =
 
 // Complete the user authorization via form_post.jwt mode
 const { code } =
-  await Credential.Issuance.completeUserAuthorizationWithFormPostJwtMode(
+  await wallet.CredentialIssuance.completeUserAuthorizationWithFormPostJwtMode(
     requestObject,
     pid.credential,
     { wiaCryptoContext, pidCryptoContext: createCryptoContextFor(pid.keyTag) }
@@ -179,11 +175,10 @@ const { code } =
 await regenerateCryptoKey(DPOP_KEYTAG); // Let's assume this function regenerates this ephemeral key for the DPoP
 const dPopCryptoContext = createCryptoContextFor(DPOP_KEYTAG);
 
-const { accessToken } = await Credential.Issuance.authorizeAccess(
+const { accessToken } = await wallet.CredentialIssuance.authorizeAccess(
   issuerConf,
   code,
-  clientId,
-  redirectUri: REDIRECT_URI,
+  REDIRECT_URI,
   codeVerifier,
   {
     walletInstanceAttestation,
@@ -198,7 +193,7 @@ const { credential_configuration_id, credential_identifiers } =
     accessToken.authorization_details[0]!;
 
  // Obtain the credential
-const { credential, format } = await Credential.Issuance.obtainCredential(
+const { credential, format } = await wallet.CredentialIssuance.obtainCredential(
   issuerConf,
   accessToken,
   clientId,
@@ -222,7 +217,7 @@ const mockX509CertRoot = format === "mso_mdoc" ? "base64encodedX509CertRoot" : u
  * WARNING: includeUndefinedAttributes should not be set to true in production in order to get only claims explicitly declared by the issuer.
  */
 const { parsedCredential } =
-  await Credential.Issuance.verifyAndParseCredential(
+  await wallet.CredentialIssuance.verifyAndParseCredential(
     issuerConf,
     credential,
     credential_configuration_id,
@@ -254,6 +249,10 @@ return {
   <summary>eID issuance flow</summary>
 
 ```ts
+import { IoWallet } from "@pagopa/io-react-native-wallet";
+
+const wallet = new IoWallet({ version: "1.0.0" });
+
 // Retrieve the integrity key tag from the store and create its context
 const integrityKeyTag = "example"; // Let's assume this is the key tag used to create the wallet instance
 const integrityContext = getIntegrityContext(integrityKeyTag);
@@ -293,25 +292,17 @@ const credentialKeyTag = uuidv4().toString();
 await generate(credentialKeyTag);
 const credentialCryptoContext = createCryptoContextFor(credentialKeyTag);
 
-// Start the issuance flow
-const startFlow: Credential.Issuance.StartFlow = () => ({
-  issuerUrl: WALLET_EID_PROVIDER_BASE_URL,
-  credentialId: "dc_sd_jwt_PersonIdentificationData",
-});
-
-const { issuerUrl, credentialId } = startFlow();
-
 // Evaluate issuer trust
-const { issuerConf } = await Credential.Issuance.evaluateIssuerTrust(
-  issuerUrl,
+const { issuerConf } = await wallet.CredentialIssuance.evaluateIssuerTrust(
+  WALLET_EID_PROVIDER_BASE_URL,
   { appFetch }
 );
 
 // Start user authorization
 const { issuerRequestUri, clientId, codeVerifier, credentialDefinition } =
-  await Credential.Issuance.startUserAuthorization(
+  await wallet.CredentialIssuance.startUserAuthorization(
     issuerConf,
-    [credentialId], // Request authorization for one or more credentials
+    ["dc_sd_jwt_PersonIdentificationData"], // Request authorization for one or more credentials
     { proofType: "none" },
     {
       walletInstanceAttestation,
@@ -323,7 +314,7 @@ const { issuerRequestUri, clientId, codeVerifier, credentialDefinition } =
 
 // Complete the authorization process with query mode with the authorizationContext which opens the browser
 const { code } =
-  await Credential.Issuance.completeUserAuthorizationWithQueryMode(
+  await wallet.CredentialIssuance.completeUserAuthorizationWithQueryMode(
     issuerRequestUri
   );
 
@@ -331,10 +322,9 @@ const { code } =
 await regenerateCryptoKey(DPOP_KEYTAG);
 const dPopCryptoContext = createCryptoContextFor(DPOP_KEYTAG);
 
-const { accessToken } = await Credential.Issuance.authorizeAccess(
+const { accessToken } = await wallet.CredentialIssuance.authorizeAccess(
   issuerConf,
   code,
-  clientId,
   redirectUri,
   codeVerifier,
   {
@@ -358,7 +348,7 @@ const { credential_configuration_id, credential_identifiers } =
     );
 
 // Obtain che eID credential
-const { credential, format } = await Credential.Issuance.obtainCredential(
+const { credential, format } = await wallet.CredentialIssuance.obtainCredential(
   issuerConf,
   accessToken,
   clientId,
@@ -374,7 +364,7 @@ const { credential, format } = await Credential.Issuance.obtainCredential(
 );
 
 // Parse and verify the eID credential
-const { parsedCredential, issuedAt, expiration } = await Credential.Issuance.verifyAndParseCredential(
+const { parsedCredential, issuedAt, expiration } = await wallet.CredentialIssuance.verifyAndParseCredential(
   issuerConf,
   credential,
   credential_configuration_id,
@@ -400,6 +390,10 @@ The result of this flow is a raw credential and a parsed credential which must b
   <summary>eID issuance flow with MRTD PoP validation</summary>
 
 ```ts
+import { IoWallet } from "@pagopa/io-react-native-wallet";
+
+const wallet = new IoWallet({ version: "1.0.0" });
+
 /**
  *
  * Previous steps are the sames as the "eID issuance flow" example
@@ -409,7 +403,7 @@ The result of this flow is a raw credential and a parsed credential which must b
 // Start user authorization indicating "mrtd-pop" as the proof type with the idpHint of the
 // chosen identification method
 const { issuerRequestUri, clientId, codeVerifier, credentialDefinition } =
-  await Credential.Issuance.startUserAuthorization(
+  await wallet.CredentialIssuance.startUserAuthorization(
     issuerConf,
     [credentialId],
     { proofType: "mrtd-pop", idpHinting: idpHint },
@@ -422,7 +416,7 @@ const { issuerRequestUri, clientId, codeVerifier, credentialDefinition } =
   );
 
 // Obtain the Authorization URL
-const { authUrl } = await Credential.Issuance.buildAuthorizationUrl(
+const { authUrl } = await wallet.CredentialIssuance.buildAuthorizationUrl(
   issuerRequestUri,
   clientId,
   issuerConf,
@@ -431,7 +425,7 @@ const { authUrl } = await Credential.Issuance.buildAuthorizationUrl(
 
 // Extract challenge info from the Authorization URL
 const { challenge_info } =
-  await Credential.Issuance.continueUserAuthorizationWithMRTDPoPChallenge(
+  await wallet.CredentialIssuance.continueUserAuthorizationWithMRTDPoPChallenge(
     authUrl
   );
 
@@ -440,7 +434,7 @@ const {
   htu: initUrl,
   mrtd_auth_session,
   mrtd_pop_jwt_nonce,
-} = await Credential.Issuance.MRTDPoP.verifyAndParseChallengeInfo(
+} = await wallet.CredentialIssuance.MRTDPoP.verifyAndParseChallengeInfo(
   issuerConf,
   challenge_info,
   { wiaCryptoContext }
@@ -451,7 +445,7 @@ const {
   htu: validationUrl,
   challenge,
   mrtd_pop_nonce,
-} = await Credential.Issuance.MRTDPoP.initChallenge(
+} = await wallet.CredentialIssuance.MRTDPoP.initChallenge(
   issuerConf,
   initUrl,
   mrtd_auth_session,
@@ -468,7 +462,7 @@ const { nis, mrtds } = /* NFC interactions functions */
 
 // Validate challenge
 const { mrtd_val_pop_nonce, redirect_uri } =
-  await Credential.Issuance.MRTDPoP.validateChallenge(
+  await wallet.CredentialIssuance.MRTDPoP.validateChallenge(
     issuerConf,
     validationUrl,
     mrtd_auth_session,
@@ -483,7 +477,7 @@ const { mrtd_val_pop_nonce, redirect_uri } =
   );
 
 // Build the callback url
-const { callbackUrl } = await Credential.Issuance.buildChallengeCallbackUrl(
+const { callbackUrl } = await wallet.CredentialIssuance.buildChallengeCallbackUrl(
   redirect_uri,
   mrtd_val_pop_nonce,
   mrtd_auth_session
@@ -494,7 +488,7 @@ const authRedirectUrl = /* From a browser or webview redirect */
 
 // Complete the authorization process with query mode using the returned callback url
 const { code } =
-  await Credential.Issuance.completeUserAuthorizationWithQueryMode(
+  await wallet.CredentialIssuance.completeUserAuthorizationWithQueryMode(
     authRedirectUrl
   );
 
@@ -503,7 +497,6 @@ const { code } =
  * The next steps are the same as the "eID issuance flow" example
  *
  */
-};
 ```
 
 The result of this flow is a raw credential and a parsed credential which must be stored securely in the wallet along with its crypto key.

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

@@ -0,0 +1,17 @@
+import type { IssuerConfig } from "./IssuerConfig";
+
+export interface EvaluateIssuerTrustApi {
+  /**
+   * The Issuer trust evaluation phase.
+   * Fetch the Issuer's configuration and verify trust.
+   * @since 1.0.0
+   *
+   * @param issuerUrl The base url of the Issuer
+   * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+   * @returns The Issuer's configuration
+   */
+  evaluateIssuerTrust(
+    issuerUrl: string,
+    ctx?: { appFetch?: GlobalFetch["fetch"] }
+  ): Promise<{ issuerConf: IssuerConfig }>;
+}