@pagopa/io-react-native-wallet 0.2.8 → 0.3.1

package/lib/typescript/rp/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rp/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBxB,CAAC;AAGH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkChC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAKxB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACO,MAAM;IACzB,MAAM,EAAE;CACtB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rp/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxB,CAAC;AAGH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkChC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAKxB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACO,MAAM;IACzB,MAAM,EAAE;CACtB,CAAC"}

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

@@ -82,4 +82,13 @@ export declare const JWK: z.ZodObject<{
     "x5t#S256"?: string | undefined;
     x5u?: string | undefined;
 }>;
+/**
+ * Ensure key values are encoded using base64url and not just base64, as defined in https://datatracker.ietf.org/doc/html/rfc7517
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc7517
+ *
+ * @param key The key to fix
+ * @returns THe same input key with fixed values
+ */
+export declare function fixBase64EncodingOnKey(key: JWK): JWK;
 //# sourceMappingURL=jwk.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"jwk.d.ts","sourceRoot":"","sources":["../../../src/utils/jwk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;AACtC,eAAO,MAAM,GAAG;IACd,uCAAuC;;;;;;;IAOvC,yCAAyC;;;IAGzC,gDAAgD;;IAEhD,oCAAoC;;IAEpC;;kCAE8B;;;;;;IAM9B,4CAA4C;;;;IAI5C,qDAAqD;;IAErD,gEAAgE;;IAEhE,mEAAmE;;IAEnE,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvC,CAAC"}
+{"version":3,"file":"jwk.d.ts","sourceRoot":"","sources":["../../../src/utils/jwk.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;AACtC,eAAO,MAAM,GAAG;IACd,uCAAuC;;;;;;;IAOvC,yCAAyC;;;IAGzC,gDAAgD;;IAEhD,oCAAoC;;IAEpC;;kCAE8B;;;;;;IAM9B,4CAA4C;;;;IAI5C,qDAAqD;;IAErD,gEAAgE;;IAEhE,mEAAmE;;IAEnE,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvC,CAAC;AAEH;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAUpD"}

package/lib/typescript/wallet-instance-attestation/issuing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issuing.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/issuing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAKnC,qBAAa,OAAO;IAClB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;gBAE7B,qBAAqB,EAAE,MAAM,EAC7B,QAAQ,GAAE,WAAW,CAAC,OAAO,CAAS;IAMxC;;;;;;;;;OASG;IACG,2BAA2B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B5D;;;;;;;;;;;;OAYG;IACG,cAAc,CAClB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC;CAqCnB"}
+{"version":3,"file":"issuing.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/issuing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAA0B,MAAM,cAAc,CAAC;AAK3D,qBAAa,OAAO;IAClB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;gBAE7B,qBAAqB,EAAE,MAAM,EAC7B,QAAQ,GAAE,WAAW,CAAC,OAAO,CAAS;IAMxC;;;;;;;;;OASG;IACG,2BAA2B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B5D;;;;;;;;;;;;OAYG;IACG,cAAc,CAClB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC;CAsCnB"}

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

@@ -32,7 +32,7 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
         iat: z.ZodNumber;
         exp: z.ZodNumber;
         cnf: z.ZodObject<{
-            jwk: z.ZodObject<{
+            jwk: z.ZodIntersection<z.ZodObject<{
                 alg: z.ZodOptional<z.ZodString>;
                 crv: z.ZodOptional<z.ZodString>;
                 d: z.ZodOptional<z.ZodString>;
@@ -101,7 +101,13 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
-            }>;
+            }>, z.ZodObject<{
+                kid: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kid: string;
+            }, {
+                kid: string;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             jwk: {
                 kty: "RSA" | "EC";
@@ -126,6 +132,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         }, {
             jwk: {
@@ -151,6 +159,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         }>;
     }, "strip", z.ZodTypeAny, {
@@ -182,6 +192,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     }, {
@@ -213,6 +225,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     }>, z.ZodObject<{
@@ -264,6 +278,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     } & {
@@ -309,6 +325,8 @@ export declare const WalletInstanceAttestationRequestJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     } & {
@@ -349,7 +367,7 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
         iat: z.ZodNumber;
         exp: z.ZodNumber;
         cnf: z.ZodObject<{
-            jwk: z.ZodObject<{
+            jwk: z.ZodIntersection<z.ZodObject<{
                 alg: z.ZodOptional<z.ZodString>;
                 crv: z.ZodOptional<z.ZodString>;
                 d: z.ZodOptional<z.ZodString>;
@@ -418,7 +436,13 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
-            }>;
+            }>, z.ZodObject<{
+                kid: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kid: string;
+            }, {
+                kid: string;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             jwk: {
                 kty: "RSA" | "EC";
@@ -443,6 +467,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         }, {
             jwk: {
@@ -468,6 +494,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         }>;
     }, "strip", z.ZodTypeAny, {
@@ -499,6 +527,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     }, {
@@ -530,6 +560,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     }>, z.ZodObject<{
@@ -648,6 +680,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     } & {
@@ -708,6 +742,8 @@ export declare const WalletInstanceAttestationJwt: z.ZodObject<{
                 x5t?: string | undefined;
                 "x5t#S256"?: string | undefined;
                 x5u?: string | undefined;
+            } & {
+                kid: string;
             };
         };
     } & {

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAwBzB,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAC;AACF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAC;AACF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BvC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA4BzB,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAC;AACF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAC;AACF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BvC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/io-react-native-wallet",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "description": "Provide data structures, helpers and API for IO Wallet",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -53,7 +53,7 @@
   "devDependencies": {
     "@pagopa/eslint-config": "^3.0.0",
     "@pagopa/io-react-native-crypto": "^0.2.3",
-    "@pagopa/io-react-native-jwt": "^0.6.0",
+    "@pagopa/io-react-native-jwt": "^0.6.4",
     "@react-native-community/eslint-config": "^3.2.0",
     "@rushstack/eslint-patch": "^1.3.2",
     "@types/jest": "^28.1.2",

package/src/rp/__test__/index.test.ts

@@ -1,5 +1,6 @@
 import { RelyingPartySolution } from "..";
 import { AuthRequestDecodeError } from "../../utils/errors";
+import { RpEntityConfiguration } from "../types";
 
 describe("decodeAuthRequestQR", () => {
   it("should return authentication request URL", async () => {
@@ -17,3 +18,224 @@ describe("decodeAuthRequestQR", () => {
     );
   });
 });
+
+describe("RpEntityConfiguration", () => {
+  it("should parse a valid confdsfashdhasd", async () => {
+    const pp = {
+      header: {
+        alg: "RS256",
+        kid: "9Cquk0X-fNPSdePQIgQcQZtD6J0IjIRrFigW2PPK_-w",
+        typ: "entity-statement+jwt",
+      },
+      payload: {
+        exp: 1692625747,
+        iat: 1692625387,
+        iss: "https://demo.proxy.eudi.wallet.developers.italia.it/OpenID4VP",
+        sub: "https://demo.proxy.eudi.wallet.developers.italia.it/OpenID4VP",
+        jwks: {
+          keys: [
+            {
+              kty: "RSA",
+              kid: "9Cquk0X-fNPSdePQIgQcQZtD6J0IjIRrFigW2PPK_-w",
+              e: "AQAB",
+              n: "utqtxbs-jnK0cPsV7aRkkZKA9t4S-WSZa3nCZtYIKDpgLnR_qcpeF0diJZvKOqXmj2cXaKFUE-8uHKAHo7BL7T-Rj2x3vGESh7SG1pE0thDGlXj4yNsg0qNvCXtk703L2H3i1UXwx6nq1uFxD2EcOE4a6qDYBI16Zl71TUZktJwmOejoHl16CPWqDLGo9GUSk_MmHOV20m4wXWkB4qbvpWVY8H6b2a0rB1B1YPOs5ZLYarSYZgjDEg6DMtZ4NgiwZ-4N1aaLwyO-GLwt9Vf-NBKwoxeRyD3zWE2FXRFBbhKGksMrCGnFDsNl5JTlPjaM3kYyImE941ggcuc495m-Fw",
+            },
+          ],
+        },
+        metadata: {
+          wallet_relying_party: {
+            application_type: "web",
+            authorization_encrypted_response_alg: [
+              "RSA-OAEP",
+              "RSA-OAEP-256",
+              "ECDH-ES",
+              "ECDH-ES+A128KW",
+              "ECDH-ES+A192KW",
+              "ECDH-ES+A256KW",
+            ],
+            authorization_encrypted_response_enc: [
+              "A128CBC-HS256",
+              "A192CBC-HS384",
+              "A256CBC-HS512",
+              "A128GCM",
+              "A192GCM",
+              "A256GCM",
+            ],
+            authorization_signed_response_alg: [
+              "RS256",
+              "RS384",
+              "RS512",
+              "ES256",
+              "ES384",
+              "ES512",
+            ],
+            client_id:
+              "https://demo.proxy.eudi.wallet.developers.italia.it/OpenID4VP",
+            client_name: "Name of an example organization",
+            contacts: ["ops@verifier.example.org"],
+            default_acr_values: [
+              "https://www.spid.gov.it/SpidL2",
+              "https://www.spid.gov.it/SpidL3",
+            ],
+            default_max_age: 1111,
+            id_token_encrypted_response_alg: [
+              "RSA-OAEP",
+              "RSA-OAEP-256",
+              "ECDH-ES",
+              "ECDH-ES+A128KW",
+              "ECDH-ES+A192KW",
+              "ECDH-ES+A256KW",
+            ],
+            id_token_encrypted_response_enc: [
+              "A128CBC-HS256",
+              "A192CBC-HS384",
+              "A256CBC-HS512",
+              "A128GCM",
+              "A192GCM",
+              "A256GCM",
+            ],
+            id_token_signed_response_alg: [
+              "RS256",
+              "RS384",
+              "RS512",
+              "ES256",
+              "ES384",
+              "ES512",
+            ],
+            presentation_definitions: [
+              {
+                id: "pid-sd-jwt:unique_id+given_name+family_name",
+                input_descriptors: [
+                  {
+                    id: "pid-sd-jwt:unique_id+given_name+family_name",
+                    format: {
+                      constraints: {
+                        fields: [
+                          {
+                            filter: {
+                              const: "PersonIdentificationData",
+                              type: "string",
+                            },
+                            path: ["$.sd-jwt.type"],
+                          },
+                          {
+                            filter: {
+                              type: "object",
+                            },
+                            path: ["$.sd-jwt.cnf"],
+                          },
+                          {
+                            intent_to_retain: "true",
+                            path: ["$.sd-jwt.family_name"],
+                          },
+                          {
+                            intent_to_retain: "true",
+                            path: ["$.sd-jwt.given_name"],
+                          },
+                          {
+                            intent_to_retain: "true",
+                            path: ["$.sd-jwt.unique_id"],
+                          },
+                        ],
+                        limit_disclosure: "required",
+                      },
+                      jwt: {
+                        alg: ["EdDSA", "ES256"],
+                      },
+                    },
+                  },
+                ],
+              },
+              {
+                id: "mDL-sample-req",
+                input_descriptors: [
+                  {
+                    format: {
+                      constraints: {
+                        fields: [
+                          {
+                            filter: {
+                              const: "org.iso.18013.5.1.mDL",
+                              type: "string",
+                            },
+                            path: ["$.mdoc.doctype"],
+                          },
+                          {
+                            filter: {
+                              const: "org.iso.18013.5.1",
+                              type: "string",
+                            },
+                            path: ["$.mdoc.namespace"],
+                          },
+                          {
+                            intent_to_retain: "false",
+                            path: ["$.mdoc.family_name"],
+                          },
+                          {
+                            intent_to_retain: "false",
+                            path: ["$.mdoc.portrait"],
+                          },
+                          {
+                            intent_to_retain: "false",
+                            path: ["$.mdoc.driving_privileges"],
+                          },
+                        ],
+                        limit_disclosure: "required",
+                      },
+                      mso_mdoc: {
+                        alg: ["EdDSA", "ES256"],
+                      },
+                    },
+                    id: "mDL",
+                  },
+                ],
+              },
+            ],
+            redirect_uris: [
+              "https://demo.proxy.eudi.wallet.developers.italia.it/OpenID4VP/redirect-uri",
+            ],
+            request_uris: [
+              "https://demo.proxy.eudi.wallet.developers.italia.it/OpenID4VP/request-uri",
+            ],
+            require_auth_time: true,
+            subject_type: "pairwise",
+            vp_formats: {
+              jwt_vp_json: {
+                alg: ["EdDSA", "ES256K"],
+              },
+            },
+            jwks: [
+              {
+                crv: "P-256",
+                d: "KzQBowMMoPmSZe7G8QsdEWc1IvR2nsgE8qTOYmMcLtc",
+                kid: "dDwPWXz5sCtczj7CJbqgPGJ2qQ83gZ9Sfs-tJyULi6s",
+                use: "sig",
+                kty: "EC",
+                x: "TSO-KOqdnUj5SUuasdlRB2VVFSqtJOxuR5GftUTuBdk",
+                y: "ByWgQt1wGBSnF56jQqLdoO1xKUynMY-BHIDB3eXlR7",
+              },
+              {
+                kty: "RSA",
+                d: "QUZsh1NqvpueootsdSjFQz-BUvxwd3Qnzm5qNb-WeOsvt3rWMEv0Q8CZrla2tndHTJhwioo1U4NuQey7znijhZ177bUwPPxSW1r68dEnL2U74nKwwoYeeMdEXnUfZSPxzs7nY6b7vtyCoA-AjiVYFOlgKNAItspv1HxeyGCLhLYhKvS_YoTdAeLuegETU5D6K1xGQIuw0nS13Icjz79Y8jC10TX4FdZwdX-NmuIEDP5-s95V9DMENtVqJAVE3L-wO-NdDilyjyOmAbntgsCzYVGH9U3W_djh4t3qVFCv3r0S-DA2FD3THvlrFi655L0QHR3gu_Fbj3b9Ybtajpue_Q",
+                e: "AQAB",
+                use: "enc",
+                kid: "9Cquk0X-fNPSdePQIgQcQZtD6J0IjIRrFigW2PPK_-w",
+                n: "utqtxbs-jnK0cPsV7aRkkZKA9t4S-WSZa3nCZtYIKDpgLnR_qcpeF0diJZvKOqXmj2cXaKFUE-8uHKAHo7BL7T-Rj2x3vGESh7SG1pE0thDGlXj4yNsg0qNvCXtk703L2H3i1UXwx6nq1uFxD2EcOE4a6qDYBI16Zl71TUZktJwmOejoHl16CPWqDLGo9GUSk_MmHOV20m4wXWkB4qbvpWVY8H6b2a0rB1B1YPOs5ZLYarSYZgjDEg6DMtZ4NgiwZ-4N1aaLwyO-GLwt9Vf-NBKwoxeRyD3zWE2FXRFBbhKGksMrCGnFDsNl5JTlPjaM3kYyImE941ggcuc495m-Fw",
+                p: "2zmGXIMCEHPphw778YjVTar1eycih6fFSJ4I4bl1iq167GqO0PjlOx6CZ1-OdBTVU7HfrYRiUK_BnGRdPDn-DQghwwkB79ZdHWL14wXnpB5y-boHz_LxvjsEqXtuQYcIkidOGaMG68XNT1nM4F9a8UKFr5hHYT5_UIQSwsxlRQ0",
+                q: "2jMFt2iFrdaYabdXuB4QMboVjPvbLA-IVb6_0hSG_-EueGBvgcBxdFGIZaG6kqHqlB7qMsSzdptU0vn6IgmCZnX-Hlt6c5X7JB_q91PZMLTO01pbZ2Bk58GloalCHnw_mjPh0YPviH5jGoWM5RHyl_HDDMI-UeLkzP7ImxGizrM",
+              },
+            ],
+          },
+        },
+        authority_hints: [
+          "https://demo.federation.eudi.wallet.developers.italia.it",
+        ],
+      },
+    };
+    const result = RpEntityConfiguration.safeParse(pp);
+    if (result.success === false) {
+      throw result.error;
+    }
+    expect(result.success).toBe(true);
+  });
+});

package/src/rp/index.ts

@@ -77,7 +77,7 @@ export class RelyingPartySolution {
    *
    */
   async getUnsignedWalletInstanceDPoP(
-    walletInstanceAttestationJwk: JWK,
+    walletInstanceAttestationJwk: any,
     authRequestUrl: string
   ): Promise<string> {
     return await new SignJWT({
@@ -109,10 +109,9 @@ export class RelyingPartySolution {
    */
   async getRequestObject(
     signedWalletInstanceDPoP: string,
+    requestUri: string,
     entity: RpEntityConfiguration
   ): Promise<RequestObject> {
-    const decodedJwtDPop = await decodeJwt(signedWalletInstanceDPoP);
-    const requestUri = decodedJwtDPop.payload.htu as string;
     const response = await this.appFetch(requestUri, {
       method: "GET",
       headers: {
@@ -122,13 +121,15 @@ export class RelyingPartySolution {
     });
 
     if (response.status === 200) {
-      const responseText = await response.text();
-      const responseJwt = decodeJwt(responseText);
+      const responseJson = await response.json();
+      const responseEncodedJwt = responseJson.response;
+
+      const responseJwt = decodeJwt(responseEncodedJwt);
 
       // verify token signature according to RP's entity configuration
       // to ensure the request object is authentic
       {
-        const pubKey = entity.payload.jwks.keys.find(
+        const pubKey = entity.payload.metadata.wallet_relying_party.jwks.find(
           ({ kid }) => kid === responseJwt.protectedHeader.kid
         );
         if (!pubKey) {
@@ -136,7 +137,7 @@ export class RelyingPartySolution {
             "Request Object signature verification"
           );
         }
-        await verify(responseText, pubKey);
+        await verify(responseEncodedJwt, pubKey);
       }
 
       // parse request object it has the expected shape by specification
@@ -163,14 +164,18 @@ export class RelyingPartySolution {
    * @todo accept more than a Verified Credential
    *
    * @param requestObj The incoming request object, which the requirements for the requested authorization
+   * @param walletInstanceIdentifier The identifies of the wallt instance that is presenting
    * @param presentation The Verified Credential containing user data along with the list of claims to be disclosed.
+   * @param signKeyId The kid of the key that will be used to sign
    * @returns The unsigned Verified Presentation token
    * @throws {ClaimsNotFoundBetweenDislosures} If the Verified Credential does not contain one or more requested claims.
    *
    */
   async prepareVpToken(
     requestObj: RequestObject,
-    [vc, claims]: Presentation // TODO: [SIW-353] support multiple presentations
+    walletInstanceIdentifier: string,
+    [vc, claims]: Presentation, // TODO: [SIW-353] support multiple presentations,
+    signKeyId: string
   ): Promise<{
     vp_token: string;
     presentation_submission: Record<string, unknown>;
@@ -180,18 +185,25 @@ export class RelyingPartySolution {
 
     // TODO: [SIW-359] check all requeste claims of the requestedObj are satisfied
 
-    const vp_token = new SignJWT({ vp })
+    const vp_token = new SignJWT({
+      vp: vp,
+      jti: `${uuid.v4()}`,
+      iss: walletInstanceIdentifier,
+      nonce: requestObj.payload.nonce,
+    })
       .setAudience(requestObj.payload.response_uri)
+      .setIssuedAt()
       .setExpirationTime("1h")
       .setProtectedHeader({
         typ: "JWT",
         alg: "ES256",
+        kid: signKeyId,
       })
       .toSign();
 
-    const [definition_id, vc_scope] = requestObj.payload.scope;
+    const vc_scope = requestObj.payload.scope;
     const presentation_submission = {
-      definition_id,
+      definition_id: `${uuid.v4()}`,
       id: `${uuid.v4()}`,
       descriptor_map: paths.map((p) => ({
         id: vc_scope,
@@ -225,94 +237,72 @@ export class RelyingPartySolution {
   ): Promise<string> {
     // the request is an unsigned jws without iss, aud, exp
     // https://openid.net/specs/openid-4-verifiable-presentations-1_0.html#name-signed-and-encrypted-respon
-    const jwk = this.choosePublicKeyToEncrypt(entity);
-    const enc = this.getEncryptionAlgByJwk(jwk);
+    const jwk = this.chooseRSAPublicKeyToEncrypt(entity);
 
     const authzResponsePayload = JSON.stringify({
       state: requestObj.payload.state,
       presentation_submission,
+      nonce: requestObj.payload.nonce,
       vp_token,
     });
+
     const encrypted = await new EncryptJwe(authzResponsePayload, {
-      alg: jwk.alg,
-      enc,
+      alg: "RSA-OAEP-256",
+      enc: "A256CBC-HS512",
+      kid: jwk.kid,
     }).encrypt(jwk);
 
     const formBody = new URLSearchParams({ response: encrypted });
+    const body = formBody.toString();
+
     const response = await this.appFetch(requestObj.payload.response_uri, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
       },
-      body: formBody.toString(),
+      body,
     });
 
     if (response.status === 200) {
-      return response.text();
+      return await response.json();
     }
 
     throw new IoWalletError(
-      `Unable to send Authorization Response. Response code: ${response.status}`
+      `Unable to send Authorization Response. Response: ${await response.text()} with code: ${
+        response.status
+      }`
     );
   }
 
   /**
-   * Select a public key from those provided by the RP.
-   * Keys with algorithm "RSA-OAEP-256" or "RSA-OAEP" are expected, the firsts to be preferred.
+   * Select a RSA public key from those provided by the RP to encrypt.
    *
    * @param entity The RP entity configuration
    * @returns A suitable public key with its compatible encryption algorithm
    * @throws {NoSuitableKeysFoundInEntityConfiguration} If entity do not contain any public key suitable for encrypting
    */
-  private choosePublicKeyToEncrypt(
-    entity: RpEntityConfiguration
-  ): (JWK & { alg: "RSA-OAEP-256" }) | (JWK & { alg: "RSA-OAEP" }) {
-    // Look for keys using "RSA-OAEP-256", and pick a random one
-    const [usingRsa256] = entity.payload.jwks.keys.filter(
-      <T>(k: T & { alg?: string }): k is T & { alg: "RSA-OAEP-256" } =>
-        typeof k.alg === "string" && k.alg === "RSA-OAEP-256"
-    );
+  private chooseRSAPublicKeyToEncrypt(entity: RpEntityConfiguration): JWK {
+    const [usingRsa256] =
+      entity.payload.metadata.wallet_relying_party.jwks.filter(
+        (jwk) => jwk.use === "enc" && jwk.kty === "RSA"
+      );
 
     if (usingRsa256) {
       return usingRsa256;
     }
 
-    // Look for keys using "RSA-OAEP", and pick a random one
-    const [usingRsa] = entity.payload.jwks.keys.filter(
-      <T>(k: T & { alg?: string }): k is T & { alg: "RSA-OAEP" } =>
-        typeof k.alg === "string" && k.alg === "RSA-OAEP"
-    );
-
-    if (usingRsa) {
-      return usingRsa;
-    }
-
     // No suitable key has been found
     throw new NoSuitableKeysFoundInEntityConfiguration(
       "Encrypt with RP public key"
     );
   }
 
-  private getEncryptionAlgByJwk({
-    alg,
-  }: (JWK & { alg: "RSA-OAEP-256" }) | (JWK & { alg: "RSA-OAEP" })):
-    | "A128CBC-HS256"
-    | "A256CBC-HS512" {
-    if (alg === "RSA-OAEP-256") return "A256CBC-HS512";
-    if (alg === "RSA-OAEP") return "A128CBC-HS256";
-
-    const _: never = alg;
-    throw new Error(`Invalid jwk algorithm: ${_}`);
-  }
-
   /**
    * Obtain the relying party entity configuration.
    */
   async getEntityConfiguration(): Promise<RpEntityConfiguration> {
-    const wellKnownUrl = new URL(
-      "/.well-known/openid-federation",
-      this.relyingPartyBaseUrl
-    ).href;
+    const wellKnownUrl =
+      this.relyingPartyBaseUrl + "/.well-known/openid-federation";
 
     const response = await this.appFetch(wellKnownUrl, {
       method: "GET",