@pagopa/io-react-native-wallet 3.1.2 → 3.2.0

package/lib/typescript/credentials-catalogue/v1.3.3/mappers.d.ts

@@ -169,6 +169,32 @@ export declare const mapToCredentialsCatalogue: (input: [{
     }[];
     last_modified?: string | undefined;
     last_updated?: string | undefined;
+}, {
+    version: string;
+    last_modified: string;
+    id: string;
+    name_l10n_id: string;
+    description_l10n_id: string;
+    domains: {
+        id: string;
+        name_l10n_id: string;
+        description_l10n_id: string;
+        classes: {
+            id: string;
+            name_l10n_id: string;
+            supported_purposes: string[];
+        }[];
+    }[];
+    purposes: {
+        id: string;
+        name_l10n_id: string;
+    }[];
+    localization?: {
+        available_locales: string[];
+        base_uri: string;
+        default_locale: string;
+        version: string;
+    } | undefined;
 }]) => {
     taxonomy_uri: string;
     credentials: {
@@ -249,6 +275,31 @@ export declare const mapToCredentialsCatalogue: (input: [{
     }[];
     iat: number;
     exp: number;
+    taxonomy?: {
+        id: string;
+        name_l10n_id: string;
+        description_l10n_id: string;
+        domains: {
+            id: string;
+            name_l10n_id: string;
+            description_l10n_id: string;
+            classes: {
+                id: string;
+                name_l10n_id: string;
+                supported_purposes: string[];
+            }[];
+        }[];
+        purposes: {
+            id: string;
+            name_l10n_id: string;
+        }[];
+        localization?: {
+            available_locales: string[];
+            base_uri: string;
+            default_locale: string;
+            version: string;
+        } | undefined;
+    } | undefined;
     localization?: {
         available_locales: string[];
         base_uri: string;

package/lib/typescript/credentials-catalogue/v1.3.3/mappers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/mappers.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmErC,CAAC"}
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/mappers.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFrC,CAAC"}

package/lib/typescript/credentials-catalogue/v1.3.3/types.d.ts

@@ -310,4 +310,37 @@ export declare const RegistryDiscoveryJwt: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;
+/**
+ * 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
+ */
+export declare const TaxonomyRegistry: z.ZodObject<{
+    version: z.ZodString;
+    last_modified: z.ZodString;
+    id: z.ZodString;
+    localization: z.ZodOptional<z.ZodObject<{
+        available_locales: z.ZodArray<z.ZodString>;
+        base_uri: z.ZodString;
+        default_locale: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+    name_l10n_id: z.ZodString;
+    description_l10n_id: z.ZodString;
+    domains: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name_l10n_id: z.ZodString;
+        description_l10n_id: z.ZodString;
+        classes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name_l10n_id: z.ZodString;
+            supported_purposes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    purposes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name_l10n_id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TaxonomyRegistry = z.infer<typeof TaxonomyRegistry>;
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/credentials-catalogue/v1.3.3/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAmCzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,MAAM;;;;;;;;;;;;;iBAUjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AA6B5C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAC;AASH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzC,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAC;AAmBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAmCzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,MAAM;;;;;;;;;;;;;iBAUjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AA6B5C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAC;AASH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzC,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAC;AAmBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA6BxE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/lib/typescript/utils/callbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../../src/utils/callbacks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAKhE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC,KAAK,sBAAsB,GAAG,IAAI,CAChC,eAAe,EACf,SAAS,GAAG,sBAAsB,CACnC,CAAC;AAQF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,sBAuC9B,CAAC;AAIF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,GAAG,EAAE,KACV,eAAe,CAAC,WAAW,CAU7B,CAAC"}
+{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../../src/utils/callbacks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,0BAA0B,CAAC;AAKhF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAGjC,KAAK,sBAAsB,GAAG,IAAI,CAChC,eAAe,EACf,SAAS,GAAG,sBAAsB,CACnC,CAAC;AA+BF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,sBAoC9B,CAAC;AAIF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,GAAG,EAAE,KACV,eAAe,CAAC,WAAW,CAU7B,CAAC"}

package/lib/typescript/utils/crypto.d.ts

@@ -1,5 +1,23 @@
 import { type CryptoContext } from "@pagopa/io-react-native-jwt";
 import { JWK } from "./jwk";
+/**
+ * Extension of the {@link CryptoContext} that adds key generation with optional key attestation.
+ *
+ * This context requires the consumer to provide an additional method for **key generation**;
+ * on Android this method should also generate a key attestation as a certificate chain
+ * to ensure the key pair is hardware-backed.
+ */
+export type KeyAttestationCryptoContext = CryptoContext & {
+    /**
+     * Generate a key pair with an **optional key attestation** (Android).
+     * @param challenge The challenge for the key attestation.
+     * @returns An object with a success flag and a key attestation, if it was generated.
+     */
+    generateKeyWithAttestation(challenge: string): Promise<{
+        success: boolean;
+        attestation?: string;
+    }>;
+};
 /**
  * Create a CryptoContext bound to a key pair.
  * Key pair is supposed to exist already in the device's keychain.
@@ -33,21 +51,20 @@ export declare const convertBase64DerToPem: (certificate: string) => string;
  */
 export declare const getSigninJwkFromCert: (pemCert: string) => JWK;
 /**
- * Extension of the {@link CryptoContext} that adds key generation with optional key attestation.
+ * Retrieves the signing JWK from a x509 certificate chain.
  *
- * This context requires the consumer to provide an additional method for **key generation**;
- * on Android this method should also generate a key attestation as a certificate chain
- * to ensure the key pair is hardware-backed.
+ * @param certChain - The x509 certificate chain.
+ * @returns The signing JWK.
+ * @throws Will throw an error if no suitable keys are found.
  */
-export type KeyAttestationCryptoContext = CryptoContext & {
-    /**
-     * Generate a key pair with an **optional key attestation** (Android).
-     * @param challenge The challenge for the key attestation.
-     * @returns An object with a success flag and a key attestation, if it was generated.
-     */
-    generateKeyWithAttestation(challenge: string): Promise<{
-        success: boolean;
-        attestation?: string;
-    }>;
-};
+export declare const getJwkFromCertificateChain: (certChain: string[]) => Promise<JWK>;
+/**
+ * Retrieves the signing JWK from a trust chain of entity configuration JWTs, matching the provided signer KID.
+ *
+ * @param trustChain - The trust chain of entity configuration JWTs.
+ * @param signerKid - The KID of the signer to look for in the trust chain.
+ * @returns The signing JWK.
+ * @throws Will throw an error if no suitable keys are found.
+ */
+export declare const getJwkFromTrustChain: (trustChain: string[], signerKid: string) => JWK;
 //# sourceMappingURL=crypto.d.ts.map

package/lib/typescript/utils/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":"AAOA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAI5B;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,aAsBvD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAU,CAAC,EACtC,IAAI,CAAC,gBAAgB,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,KAClD,OAAO,CAAC,CAAC,CAMX,CAAC;AACF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,KAAG,MACc,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,KAAG,GAetD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,aAAa,GAAG;IACxD;;;;OAIG;IACH,0BAA0B,CACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD,CAAC"}
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,GAAG,EAAQ,MAAM,OAAO,CAAC;AAIlC;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,aAAa,GAAG;IACxD;;;;OAIG;IACH,0BAA0B,CACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,aAsBvD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAU,CAAC,EACtC,IAAI,CAAC,gBAAgB,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,KAClD,OAAO,CAAC,CAAC,CAMX,CAAC;AACF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,KAAG,MACc,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,KAAG,GAetD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACrC,WAAW,MAAM,EAAE,KAClB,OAAO,CAAC,GAAG,CASb,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAAE,EACpB,WAAW,MAAM,KAChB,GAiCF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/io-react-native-wallet",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "description": "Provide data structures, helpers and API for IO Wallet",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/credential/issuance/README.md

@@ -8,6 +8,8 @@ Credentials instead require a simpler authorization flow and they require other
 
 The supported credentials are defined in the entity configuration of the issuer which is evaluted and parsed in the `evaluateIssuerTrust` step. Available credentials are identified with a unique `credential_configuration_id`, that must be used when requesting authorization. The Authorization Server returns an array of **credential identifiers** that map to the `credential_configuration_id` provided: to obtain the credential, one of the credential identifiers (or all of them) must be requested to the credential endpoint.
 
+In the newest versions of IT-Wallet specifications it is mandatory that the cryptographic keys bound to each credential are stored in a WSCD and attested in a **Wallet Unit Attestation**, that must be sent to the Issuer when requesting a credential.
+
 ## Sequence Diagram
 
 ```mermaid
@@ -20,8 +22,9 @@ graph TD;
     C4.1[completeUserAuthorizationWithFormPostJwtMode]
     E4[completeUserAuthorizationWithQueryMode]
     5[authorizeAccess]
-    6[obtainCredential]
-    7[verifyAndParseCredential]
+    6[WalletUnitAttestation.getAttestation]
+    7[obtainCredential]
+    8[verifyAndParseCredential]
     credSel{Is credential an eID?}
     proofSel{Requires MRTD PoP?}
     M1[continueUserAuthorizationWithMRTDPoPChallenge]
@@ -44,6 +47,7 @@ graph TD;
     E4 --> 5
     5 --> 6
     6 --> 7
+    7 --> 8
 
     M1 --> M2
     M2 --> M3
@@ -92,6 +96,10 @@ When the credential is different than an eID, the flow requires the user to pres
 
 The expected result from the authentication process is in `form_post.jwt` format as defined in [JWT Secured Authorization Response Mode for OAuth 2.0 (JARM)](https://openid.net/specs/oauth-v2-jarm.html#name-response-mode-form_postjwt).
 
+## Batch issuance
+
+To obtain a batch of credentials the Issuance module exposes a dedicated method—`obtainCredentialsBatch`—that returns a list of credentials of the same type with different cryptographic data. For this reason the caller must generate multiple keys and attest them in a single Wallet Unit Attestation.
+
 ## Examples
 
 <details>
@@ -119,12 +127,28 @@ const { WALLET_PROVIDER_BASE_URL, WALLET_EAA_PROVIDER_BASE_URL, REDIRECT_URI } =
  * WARNING: The integrity context must be the same used when creating the Wallet Instance with the same keytag.
  */
 const walletInstanceAttestation =
-  await WalletInstanceAttestation.getAttestation({
-    wiaCryptoContext,
-    integrityContext,
-    walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
-    appFetch,
-  });
+  await wallet.WalletInstanceAttestation.getAttestation(
+    {
+      walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
+      walletSolutionId: "exampleId",
+      walletSolutionVersion: "1.2.3",
+    },
+    {
+      wiaCryptoContext,
+      integrityContext,
+      appFetch,
+    }
+  );
+
+const credentialKeyTag = uuidv4().toString();
+let walletUnitAttestation: string | undefined;
+
+// Obtains a Wallet Unit Attestation if supported
+if (wallet.WalletUnitAttestation.isSupported) {
+  walletUnitAttestation = await wallet.WalletUnitAttestation.getAttestation(); // See the Wallet Unit Attestation README for more details
+} else {
+  await generate(credentialKeyTag); // Let's assume this function generates a new hardware-backed key pair
+}
 
 const pid = {
   credential: "example",
@@ -133,9 +157,6 @@ const pid = {
   credentialType: "PersonIdentificationData";
 };
 
-// Create credential crypto context
-const credentialKeyTag = uuidv4().toString();
-await generate(credentialKeyTag); // Let's assume this function generates a new hardware-backed key pair
 const credentialCryptoContext = createCryptoContextFor(credentialKeyTag);
 
 // Evaluate issuer trust
@@ -271,12 +292,18 @@ const { WALLET_PROVIDER_BASE_URL, WALLET_EID_PROVIDER_BASE_URL, REDIRECT_URI } =
  * WARNING: The integrity context must be the same used when creating the Wallet Instance with the same keytag.
  */
 const walletInstanceAttestation =
-  await WalletInstanceAttestation.getAttestation({
-    wiaCryptoContext,
-    integrityContext,
-    walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
-    appFetch,
-  });
+  await wallet.WalletInstanceAttestation.getAttestation(
+    {
+      walletProviderBaseUrl: WALLET_PROVIDER_BASE_URL,
+      walletSolutionId: "exampleId",
+      walletSolutionVersion: "1.2.3",
+    },
+    {
+      wiaCryptoContext,
+      integrityContext,
+      appFetch,
+    }
+  );
 
 const idpHit = "https://example.com"; // Let's assume this is the IDP hint
 

package/src/credential/issuance/api/05-obtain-credential.ts

@@ -41,4 +41,28 @@ export interface ObtainCredentialApi {
     credential: string;
     format: CredentialFormat;
   }>;
+
+  /**
+   * Obtains a batch of credentials from the issuer.
+   * The batch includes the same credential format and dataset with different cryptographic data.
+   * For this reason, the function accepts a list of {@link CryptoContext}; the rest of the parameters are the same as {@link obtainCredential}.
+   * @since 1.3.3
+   *
+   * @returns The list of credentials issued in the batch.
+   */
+  obtainCredentialsBatch(
+    issuerConf: IssuerConfig,
+    accessToken: Out<AuthorizeAccessApi["authorizeAccess"]>["accessToken"],
+    clientId: string,
+    credentialDefinition: {
+      credential_configuration_id: string;
+      credential_identifier: string;
+    },
+    context: {
+      dPopCryptoContext: CryptoContext;
+      credentialCryptoContexts: CryptoContext[];
+      walletUnitAttestation?: string;
+      appFetch?: GlobalFetch["fetch"];
+    }
+  ): Promise<{ credential: string; format: CredentialFormat }[]>;
 }

package/src/credential/issuance/v1.0.0/03-complete-user-authorization.ts

@@ -17,7 +17,7 @@ import { ResponseUriResultShape } from "./types";
 import { getJwtFromFormPost } from "../../../utils/decoder";
 import { AuthorizationError, AuthorizationIdpError } from "../common/errors";
 import { LogLevel, Logger } from "../../../utils/logging";
-import { RequestObjectPayload } from "../../presentation/v1.0.0/types";
+import { RawRequestObject } from "../../presentation/v1.0.0/types";
 import { RemotePresentation as RemotePresentationFlow } from "../../presentation/v1.0.0";
 import type { IssuanceApi } from "../api";
 import type { RemotePresentation } from "../../presentation";
@@ -105,7 +105,12 @@ export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCrede
       .then(hasStatusOrThrow(200, IssuerResponseError))
       .then((res) => res.text())
       .then((jws) => decode(jws))
-      .then((reqObj) => RequestObjectPayload.safeParse(reqObj.payload));
+      .then((reqObj) =>
+        RawRequestObject.safeParse({
+          header: reqObj.protectedHeader,
+          payload: reqObj.payload,
+        })
+      );
 
     if (!requestObject.success) {
       Logger.log(
@@ -117,7 +122,7 @@ export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCrede
         reason: requestObject.error.message,
       });
     }
-    return requestObject.data;
+    return requestObject.data.payload;
   };
 
 export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["completeUserAuthorizationWithFormPostJwtMode"] =

package/src/credential/issuance/v1.0.0/05-obtain-credential.ts

@@ -10,6 +10,7 @@ import {
   IssuerResponseErrorCodes,
   ResponseErrorBuilder,
   UnexpectedStatusCodeError,
+  UnimplementedFeatureError,
   ValidationFailed,
 } from "../../../utils/errors";
 import { createDPopToken } from "../../../utils/dpop";
@@ -210,3 +211,8 @@ const handleObtainCredentialError = (e: unknown) => {
     })
     .buildFrom(e);
 };
+
+export const obtainCredentialsBatch: IssuanceApi["obtainCredentialsBatch"] =
+  () => {
+    throw new UnimplementedFeatureError("obtainCredentialsBatch", "1.0.0");
+  };

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

@@ -9,7 +9,10 @@ import {
   getRequestedCredentialToBePresented,
 } from "./03-complete-user-authorization";
 import { authorizeAccess } from "./04-authorize-access";
-import { obtainCredential } from "./05-obtain-credential";
+import {
+  obtainCredential,
+  obtainCredentialsBatch,
+} from "./05-obtain-credential";
 import { verifyAndParseCredential } from "./06-verify-and-parse-credential";
 import { MRTDPoP } from "../mrtd-pop";
 
@@ -23,6 +26,7 @@ export const Issuance: IssuanceApi = {
   completeUserAuthorizationWithFormPostJwtMode,
   authorizeAccess,
   obtainCredential,
+  obtainCredentialsBatch,
   verifyAndParseCredential,
   MRTDPoP,
 };

package/src/credential/issuance/v1.3.3/03-complete-user-authorization.ts

@@ -16,11 +16,11 @@ import { AuthorizationError, AuthorizationIdpError } from "../common/errors";
 import { LogLevel, Logger } from "../../../utils/logging";
 import { RemotePresentation as RemotePresentationFlow } from "../../presentation/v1.3.3";
 import { partialCallbacks } from "../../../utils/callbacks";
+import { sdkConfigV1_3 } from "../../../utils/config";
 import {
   IoWalletError,
   sdkUnexpectedStatusCodeToIssuerError,
 } from "../../../utils/errors";
-import { sdkConfigV1_3 } from "../../../utils/config";
 import type { IssuanceApi } from "../api";
 import { mapToRequestObject } from "./mappers";
 import type { RemotePresentation } from "../../presentation";